RedisArray*
ra_load_hosts(RedisArray *ra, HashTable *hosts, long retry_interval TSRMLS_DC)
{
int i, host_len, id;
int count = zend_hash_num_elements(hosts);
char *host, *p;
short port;
zval **zpData, z_cons, z_ret;
RedisSock *redis_sock = NULL;
/* function calls on the Redis object */
ZVAL_STRING(&z_cons, "__construct", 0);
/* init connections */
for(i = 0; i < count; ++i) {
if(FAILURE == zend_hash_quick_find(hosts, NULL, 0, i, (void**)&zpData)) {
efree(ra);
return NULL;
}
ra->hosts[i] = estrdup(Z_STRVAL_PP(zpData));
/* default values */
host = Z_STRVAL_PP(zpData);
host_len = Z_STRLEN_PP(zpData);
port = 6379;
if((p = strchr(host, ':'))) { /* found port */
host_len = p - host;
port = (short)atoi(p+1);
}
/* create Redis object */
MAKE_STD_ZVAL(ra->redis[i]);
object_init_ex(ra->redis[i], redis_ce);
INIT_PZVAL(ra->redis[i]);
call_user_function(&redis_ce->function_table, &ra->redis[i], &z_cons, &z_ret, 0, NULL TSRMLS_CC);
/* create socket */
redis_sock = redis_sock_create(host, host_len, port, 0, 0, NULL, retry_interval); /* TODO: persistence? */
/* connect */
redis_sock_server_open(redis_sock, 1 TSRMLS_CC);
/* attach */
#if PHP_VERSION_ID >= 50400
id = zend_list_insert(redis_sock, le_redis_sock TSRMLS_CC);
#else
id = zend_list_insert(redis_sock, le_redis_sock);
#endif
add_property_resource(ra->redis[i], "socket", id);
}
return ra;
}
/* {{{ proto int pspell_new_config(int config)
Load a dictionary based on the given config */
static PHP_FUNCTION(pspell_new_config)
{
zend_long conf;
zval *ind;
PspellCanHaveError *ret;
PspellManager *manager;
PspellConfig *config;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "l", &conf) == FAILURE) {
return;
}
PSPELL_FETCH_CONFIG;
ret = new_pspell_manager(config);
if (pspell_error_number(ret) != 0) {
php_error_docref(NULL, E_WARNING, "PSPELL couldn't open the dictionary. reason: %s", pspell_error_message(ret));
delete_pspell_can_have_error(ret);
RETURN_FALSE;
}
manager = to_pspell_manager(ret);
ind = zend_list_insert(manager, le_pspell);
RETURN_LONG(Z_RES_HANDLE_P(ind));
}
/*
* save a corba object to a php object
*/
void orbit_save_data(zval * php_object, int type, void * data)
{
pval * orbit_data_handle = NULL;
long id = zend_list_insert(
data, /* data */
type /* type */
);
/*
* do it like they do in php_COM_call_function_handler
* (insert into some magic hash index)
*/
ALLOC_ZVAL(orbit_data_handle); /* allocate memory for value */
orbit_data_handle->type = IS_LONG;
orbit_data_handle->value.lval = id;
pval_copy_constructor(orbit_data_handle); /* why? */
INIT_PZVAL(orbit_data_handle); /* set reference count */
zend_hash_index_update(
php_object->value.obj.properties, /* hashtable */
0, /* hash??? */
&orbit_data_handle, /* data */
sizeof(pval *), /* data size */
NULL /* destination */
);
}
RedisArray*
ra_load_hosts(RedisArray *ra, HashTable *hosts, long retry_interval, zend_bool b_lazy_connect)
{
int i = 0, host_len;
zval *id;
char *host, *p;
short port;
zval *zpData, z_cons, z_ret;
RedisSock *redis_sock = NULL;
/* function calls on the Redis object */
ZVAL_STRING(&z_cons, "__construct");
/* init connections */
ZEND_HASH_FOREACH_VAL(hosts, zpData) {
if (Z_TYPE_P(zpData) != IS_STRING) {
efree(ra);
return NULL;
}
ra->hosts[i] = estrdup(Z_STRVAL_P(zpData));
/* default values */
host = Z_STRVAL_P(zpData);
host_len = Z_STRLEN_P(zpData);
port = 6379;
if ((p = strchr(host, ':'))) { /* found port */
host_len = p - host;
port = (short)atoi(p+1);
} else if (strchr(host,'/') != NULL) { /* unix socket */
port = -1;
}
/* create Redis object */
object_init_ex(&ra->redis[i], redis_ce);
call_user_function(&redis_ce->function_table, &ra->redis[i], &z_cons, &z_ret, 0, NULL);
/* create socket */
redis_sock = redis_sock_create(host, host_len, port, ra->connect_timeout, ra->pconnect, NULL, retry_interval, b_lazy_connect);
if (!b_lazy_connect)
{
/* connect */
redis_sock_server_open(redis_sock, 1);
}
/* attach */
id = zend_list_insert(redis_sock, le_redis_sock);
add_property_resource(&ra->redis[i], "socket", Z_RES_P(id));
i++;
} ZEND_HASH_FOREACH_END();
return ra;
}
static int birdstep_add_result(HashTable *list,Vresult *res,VConn *conn)
{
int ind;
ind = zend_list_insert(res,php_birdstep_module.le_result);
res->conn = conn;
res->index = ind;
return(ind);
}
static int birdstep_add_conn(HashTable *list,VConn *conn,HDBC hdbc)
{
int ind;
ind = zend_list_insert(conn,php_birdstep_module.le_link);
conn->hdbc = hdbc;
conn->index = ind;
return(ind);
}
PHP_COM_DOTNET_API IStream *php_com_wrapper_export_stream(php_stream *stream)
{
php_istream *stm = (php_istream*)CoTaskMemAlloc(sizeof(*stm));
zval *tmp;
if (stm == NULL)
return NULL;
memset(stm, 0, sizeof(*stm));
stm->engine_thread = GetCurrentThreadId();
stm->lpVtbl = &php_istream_vtbl;
stm->refcount = 1;
stm->stream = stream;
GC_REFCOUNT(stream->res)++;
tmp = zend_list_insert(stm, le_istream);
stm->res = Z_RES_P(tmp);
return (IStream*)stm;
}
/* {{{ pip_pyobject_to_zobject(PyObject *obj)
Convert Python object to a PHP (Zend) object */
zval *
pip_pyobject_to_zobject(PyObject *obj)
{
pval *ret;
zval *handle;
TSRMLS_FETCH();
/* Create a PHP Python object */
MAKE_STD_ZVAL(ret);
object_init_ex(ret, &python_class_entry);
ret->is_ref = 1;
ret->refcount = 1;
/* Assign the current PyObject to the new PHP Python object */
ALLOC_ZVAL(handle);
ZVAL_RESOURCE(handle, zend_list_insert(obj, le_pyobject));
zval_copy_ctor(handle);
INIT_PZVAL(handle);
zend_hash_index_update(Z_OBJPROP_P(ret), 0, &handle, sizeof(zval *), NULL);
return ret;
}
RedisArray*
ra_load_hosts(RedisArray *ra, HashTable *hosts, long retry_interval, zend_bool b_lazy_connect TSRMLS_DC)
{
int i = 0, host_len;
zval *id;
char *host, *p;
short port;
zval *zpData, z_cons, z_ret;
RedisSock *redis_sock = NULL;
/* function calls on the Redis object */
ZVAL_STRING(&z_cons, "__construct");
/* init connections */
for (zend_hash_internal_pointer_reset(hosts);
zend_hash_has_more_elements(hosts) == SUCCESS;
zend_hash_move_forward(hosts))
{
if ((zpData = zend_hash_get_current_data(hosts)) == NULL || (Z_TYPE_P(zpData) != IS_STRING))
{
zval_dtor(&z_cons);
efree(ra);
return NULL;
}
ra->hosts[i] = estrdup(Z_STRVAL_P(zpData));
/* default values */
host = Z_STRVAL_P(zpData);
host_len = Z_STRLEN_P(zpData);
port = 6379;
if(((p = strrchr(host, ':')))) { /* found port */
host_len = p - host;
port = (short)atoi(p+1);
} else if(strchr(host,'/') != NULL) { /* unix socket */
port = -1;
}
/* create Redis object */
object_init_ex(&ra->redis[i], redis_ce);
call_user_function(&redis_ce->function_table, &ra->redis[i], &z_cons, &z_ret, 0, NULL TSRMLS_CC);
/* create socket */
redis_sock = redis_sock_create(host, host_len, port, ra->connect_timeout, ra->pconnect, NULL, retry_interval, b_lazy_connect);
if (!b_lazy_connect) {
/* connect */
redis_sock_server_open(redis_sock, 1 TSRMLS_CC);
}
/* attach */
id = zend_list_insert(redis_sock, le_redis_sock TSRMLS_CC);
add_property_resource(&ra->redis[i], "socket", Z_RES_P(id));
i++;
}
/* Cleanup constructor zval */
zval_dtor(&z_cons);
return ra;
}
/* ArchiveReader::__construct {{{
*
*/
ZEND_METHOD(ArchiveReader, __construct)
{
archive_file_t *arch = NULL;
int resource_id;
zval *this = getThis();
const char *error_string = NULL;
char *filename;
long error_num, filename_len, result, format = 0, compression = 0, block_size = 0;
zend_error_handling error_handling;
zend_replace_error_handling(EH_THROW, ce_ArchiveException, &error_handling TSRMLS_CC);
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|lll", &filename, &filename_len, &format, &compression, &block_size) == FAILURE) {
zend_restore_error_handling(&error_handling TSRMLS_CC);
return;
}
#if PHP_API_VERSION < 20100412
if (PG(safe_mode) && (!php_checkuid(filename, NULL, CHECKUID_CHECK_FILE_AND_DIR))) {
zend_restore_error_handling(&error_handling TSRMLS_CC);
return;
}
#endif
if (php_check_open_basedir(filename TSRMLS_CC)) {
zend_restore_error_handling(&error_handling TSRMLS_CC);
return;
}
if(block_size <= 0){
block_size = PHP_ARCHIVE_BUF_LEN;
}
arch = (archive_file_t *) emalloc(sizeof(archive_file_t));
arch->stream = NULL;
arch->current_entry = NULL;
arch->entries = NULL;
arch->struct_state = ARCHIVE_OK;
arch->block_size = block_size;
arch->mode = PHP_ARCHIVE_READ_MODE;
arch->buf = emalloc(arch->block_size + 1);
arch->filename = estrndup(filename, filename_len);
arch->arch = archive_read_new();
archive_read_support_filter_all(arch->arch);
switch(format){
case PHP_ARCHIVE_FORMAT_TAR:
archive_read_support_format_tar(arch->arch);
break;
case PHP_ARCHIVE_FORMAT_CPIO:
archive_read_support_format_cpio(arch->arch);
break;
default:
archive_read_support_format_all(arch->arch);
break;
}
switch(compression){
case PHP_ARCHIVE_COMPRESSION_NONE:
break;
case PHP_ARCHIVE_COMPRESSION_GZIP:
if(archive_read_support_filter_gzip(arch->arch) != ARCHIVE_OK){
efree(arch->filename);
efree(arch->buf);
efree(arch);
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Gzip compression support is not available in this build ");
zend_restore_error_handling(&error_handling TSRMLS_CC);
return;
}
break;
case PHP_ARCHIVE_COMPRESSION_BZIP2:
if(archive_read_support_filter_gzip(arch->arch) != ARCHIVE_OK){
efree(arch->filename);
efree(arch->buf);
efree(arch);
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Bzip2 compression support is not available in this build ");
zend_restore_error_handling(&error_handling TSRMLS_CC);
return;
}
default:
archive_read_support_filter_all(arch->arch);
break;
}
result = archive_read_open(arch->arch, arch, _archive_open_clbk, _archive_read_clbk, _archive_close_clbk);
if (result) {
error_num = archive_errno(arch->arch);
error_string = archive_error_string(arch->arch);
if (arch->stream) {
php_stream_close(arch->stream);
}
if (error_num && error_string) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed to open file %s for reading: error #%d, %s", filename, error_num, error_string);
}
else {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed to open file %s for reading: unknown error %d", filename, result);
}
zend_restore_error_handling(&error_handling TSRMLS_CC);
archive_read_close(arch->arch);
archive_read_free(arch->arch);
efree(arch->filename);
efree(arch->buf);
efree(arch);
return;
}
resource_id = zend_list_insert(arch,le_archive);
add_property_resource(this, "fd", resource_id);
zend_restore_error_handling(&error_handling TSRMLS_CC);
return;
}
/* ArchiveReader::getNextEntry {{{
*
*/
ZEND_METHOD(ArchiveReader, getNextEntry)
{
zval *this = getThis();
archive_file_t *arch;
int result, error_num, resource_id;
const char *error_string;
zend_bool fetch_entry_data = 0;
archive_entry_t *entry;
struct archive_entry *current_entry;
size_t len;
off_t offset;
char *buf;
zend_error_handling error_handling;
zend_replace_error_handling(EH_THROW, ce_ArchiveException, &error_handling TSRMLS_CC);
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|b", &fetch_entry_data) == FAILURE) {
zend_restore_error_handling(&error_handling TSRMLS_CC);
return;
}
if (!_archive_get_fd(this, &arch TSRMLS_CC)) {
zend_restore_error_handling(&error_handling TSRMLS_CC);
return;
}
if (arch->struct_state == ARCHIVE_OK) {
result = archive_read_next_header(arch->arch, ¤t_entry);
arch->struct_state = result;
entry = (archive_entry_t *) emalloc(sizeof(archive_entry_t));
entry->entry = current_entry;
entry->data = NULL;
entry->filename = NULL;
entry->resolved_filename = NULL;
entry->data_len = 0;
arch->current_entry = entry;
}
else {
zend_restore_error_handling(&error_handling TSRMLS_CC);
RETURN_FALSE;
}
if (result && result != ARCHIVE_EOF) {
arch->current_entry = NULL;
error_num = archive_errno(arch->arch);
error_string = archive_error_string(arch->arch);
efree(entry);
if (error_num && error_string) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed to read file %s: error #%d, %s", arch->filename, error_num, error_string);
}
else {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed to read file %s: unknown error %d", arch->filename, result);
}
zend_restore_error_handling(&error_handling TSRMLS_CC);
return;
}
if (result == ARCHIVE_EOF) {
arch->current_entry = NULL;
efree(entry);
zend_restore_error_handling(&error_handling TSRMLS_CC);
RETURN_FALSE;
}
object_init_ex(return_value, ce_ArchiveEntry);
if (fetch_entry_data) {
while ((result = archive_read_data_block(arch->arch, (const void **)&buf, &len, &offset)) == ARCHIVE_OK) {
entry->data = erealloc(entry->data, entry->data_len + len + 1);
memcpy(entry->data + entry->data_len, buf, len);
entry->data_len += len;
}
if (result && result != ARCHIVE_EOF) {
error_num = archive_errno(arch->arch);
error_string = archive_error_string(arch->arch);
efree(entry);
if (error_num && error_string) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed to read file %s: error #%d, %s", arch->filename, error_num, error_string);
}
else {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed to read file %s: unknown error %d", arch->filename, result);
}
zend_restore_error_handling(&error_handling TSRMLS_CC);
return;
}
}
if (entry->entry) {
resource_id = zend_list_insert(entry,le_archive_entry);
add_property_resource(return_value, "entry", resource_id);
}
zend_restore_error_handling(&error_handling TSRMLS_CC);
}
/* {{{ proto int pspell_config_create(string language [, string spelling [, string jargon [, string encoding]]])
Create a new config to be used later to create a manager */
static PHP_FUNCTION(pspell_config_create)
{
char *language, *spelling = NULL, *jargon = NULL, *encoding = NULL;
size_t language_len, spelling_len = 0, jargon_len = 0, encoding_len = 0;
zval *ind;
PspellConfig *config;
#ifdef PHP_WIN32
TCHAR aspell_dir[200];
TCHAR data_dir[220];
TCHAR dict_dir[220];
HKEY hkey;
DWORD dwType,dwLen;
#endif
if (zend_parse_parameters(ZEND_NUM_ARGS(), "s|sss", &language, &language_len, &spelling, &spelling_len,
&jargon, &jargon_len, &encoding, &encoding_len) == FAILURE) {
return;
}
config = new_pspell_config();
#ifdef PHP_WIN32
/* If aspell was installed using installer, we should have a key
* pointing to the location of the dictionaries
*/
if (0 == RegOpenKey(HKEY_LOCAL_MACHINE, "Software\\Aspell", &hkey)) {
LONG result;
dwLen = sizeof(aspell_dir) - 1;
result = RegQueryValueEx(hkey, "", NULL, &dwType, (LPBYTE)&aspell_dir, &dwLen);
RegCloseKey(hkey);
if (result == ERROR_SUCCESS) {
strlcpy(data_dir, aspell_dir, sizeof(data_dir));
strlcat(data_dir, "\\data", sizeof(data_dir));
strlcpy(dict_dir, aspell_dir, sizeof(dict_dir));
strlcat(dict_dir, "\\dict", sizeof(dict_dir));
pspell_config_replace(config, "data-dir", data_dir);
pspell_config_replace(config, "dict-dir", dict_dir);
}
}
#endif
pspell_config_replace(config, "language-tag", language);
if (spelling_len) {
pspell_config_replace(config, "spelling", spelling);
}
if (jargon_len) {
pspell_config_replace(config, "jargon", jargon);
}
if (encoding_len) {
pspell_config_replace(config, "encoding", encoding);
}
/* By default I do not want to write anything anywhere because it'll try to write to $HOME
which is not what we want */
pspell_config_replace(config, "save-repl", "false");
ind = zend_list_insert(config, le_pspell_config);
RETURN_LONG(Z_RES_HANDLE_P(ind));
}
/* {{{ proto int pspell_new_personal(string personal, string language [, string spelling [, string jargon [, string encoding [, int mode]]]])
Load a dictionary with a personal wordlist*/
static PHP_FUNCTION(pspell_new_personal)
{
char *personal, *language, *spelling = NULL, *jargon = NULL, *encoding = NULL;
size_t personal_len, language_len, spelling_len = 0, jargon_len = 0, encoding_len = 0;
zend_long mode = Z_L(0), speed = Z_L(0);
int argc = ZEND_NUM_ARGS();
zval *ind;
#ifdef PHP_WIN32
TCHAR aspell_dir[200];
TCHAR data_dir[220];
TCHAR dict_dir[220];
HKEY hkey;
DWORD dwType,dwLen;
#endif
PspellCanHaveError *ret;
PspellManager *manager;
PspellConfig *config;
if (zend_parse_parameters(argc, "ps|sssl", &personal, &personal_len, &language, &language_len,
&spelling, &spelling_len, &jargon, &jargon_len, &encoding, &encoding_len, &mode) == FAILURE) {
return;
}
config = new_pspell_config();
#ifdef PHP_WIN32
/* If aspell was installed using installer, we should have a key
* pointing to the location of the dictionaries
*/
if (0 == RegOpenKey(HKEY_LOCAL_MACHINE, "Software\\Aspell", &hkey)) {
LONG result;
dwLen = sizeof(aspell_dir) - 1;
result = RegQueryValueEx(hkey, "", NULL, &dwType, (LPBYTE)&aspell_dir, &dwLen);
RegCloseKey(hkey);
if (result == ERROR_SUCCESS) {
strlcpy(data_dir, aspell_dir, sizeof(data_dir));
strlcat(data_dir, "\\data", sizeof(data_dir));
strlcpy(dict_dir, aspell_dir, sizeof(dict_dir));
strlcat(dict_dir, "\\dict", sizeof(dict_dir));
pspell_config_replace(config, "data-dir", data_dir);
pspell_config_replace(config, "dict-dir", dict_dir);
}
}
#endif
if (php_check_open_basedir(personal)) {
delete_pspell_config(config);
RETURN_FALSE;
}
pspell_config_replace(config, "personal", personal);
pspell_config_replace(config, "save-repl", "false");
pspell_config_replace(config, "language-tag", language);
if (spelling_len) {
pspell_config_replace(config, "spelling", spelling);
}
if (jargon_len) {
pspell_config_replace(config, "jargon", jargon);
}
if (encoding_len) {
pspell_config_replace(config, "encoding", encoding);
}
if (argc > 5) {
speed = mode & PSPELL_SPEED_MASK_INTERNAL;
/* First check what mode we want (how many suggestions) */
if (speed == PSPELL_FAST) {
pspell_config_replace(config, "sug-mode", "fast");
} else if (speed == PSPELL_NORMAL) {
pspell_config_replace(config, "sug-mode", "normal");
} else if (speed == PSPELL_BAD_SPELLERS) {
pspell_config_replace(config, "sug-mode", "bad-spellers");
}
/* Then we see if run-together words should be treated as valid components */
if (mode & PSPELL_RUN_TOGETHER) {
pspell_config_replace(config, "run-together", "true");
}
}
ret = new_pspell_manager(config);
delete_pspell_config(config);
if (pspell_error_number(ret) != 0) {
php_error_docref(NULL, E_WARNING, "PSPELL couldn't open the dictionary. reason: %s", pspell_error_message(ret));
delete_pspell_can_have_error(ret);
RETURN_FALSE;
}
manager = to_pspell_manager(ret);
ind = zend_list_insert(manager, le_pspell);
RETURN_LONG(Z_RES_HANDLE_P(ind));
}
static void php_dba_open(INTERNAL_FUNCTION_PARAMETERS, int persistent)
{
pval ***args = (pval ***) NULL;
int ac = ZEND_NUM_ARGS();
dba_mode_t modenr;
dba_info *info;
dba_handler *hptr;
char *key = NULL;
int keylen = 0;
int listid;
int i;
if(ac < 3) {
WRONG_PARAM_COUNT;
}
/* we pass additional args to the respective handler */
args = emalloc(ac * sizeof(pval *));
if(zend_get_parameters_array_ex(ac, args) != SUCCESS) {
FREENOW;
WRONG_PARAM_COUNT;
}
/* we only take string arguments */
for(i = 0; i < ac; i++) {
convert_to_string_ex(args[i]);
keylen += Z_STRLEN_PP(args[i]);
}
if(persistent) {
/* calculate hash */
key = emalloc(keylen);
keylen = 0;
for(i = 0; i < ac; i++) {
memcpy(key+keylen,Z_STRVAL_PP(args[i]),Z_STRLEN_PP(args[i]));
keylen += Z_STRLEN_PP(args[i]);
}
if(zend_hash_find(&ht_keys, key, keylen, (void **) &info) == SUCCESS) {
FREENOW;
RETURN_LONG(zend_list_insert(info, GLOBAL(le_pdb)));
}
}
for(hptr = handler; hptr->name &&
strcasecmp(hptr->name, (*args[2])->value.str.val); hptr++);
if(!hptr->name) {
php_error(E_WARNING, "no such handler: %s", (*args[2])->value.str.val);
FREENOW;
RETURN_FALSE;
}
switch((*args[1])->value.str.val[0]) {
case 'c':
modenr = DBA_CREAT;
break;
case 'w':
modenr = DBA_WRITER;
break;
case 'r':
modenr = DBA_READER;
break;
case 'n':
modenr = DBA_TRUNC;
break;
default:
php_error(E_WARNING,"illegal DBA mode: %s",(*args[1])->value.str.val);
FREENOW;
RETURN_FALSE;
}
info = malloc(sizeof(*info));
memset(info, 0, sizeof(info));
info->path = strdup((*args[0])->value.str.val);
info->mode = modenr;
info->argc = ac - 3;
info->argv = args + 3;
info->hnd = NULL;
if(hptr->open(info) != SUCCESS) {
dba_close(info);
php_error(E_WARNING, "driver initialization failed");
FREENOW;
RETURN_FALSE;
}
info->hnd = hptr;
info->argc = 0;
info->argv = NULL;
listid = zend_list_insert(info, persistent?GLOBAL(le_pdb):GLOBAL(le_db));
if(persistent) {
zend_hash_update(&ht_keys, key, keylen, info, sizeof(*info), NULL);
}
FREENOW;
RETURN_LONG(listid);
}
static void _php_do_opendir(INTERNAL_FUNCTION_PARAMETERS, int createobject)
{
pval **arg;
php_dir *dirp;
DIRLS_FETCH();
if (ZEND_NUM_ARGS() != 1 || zend_get_parameters_ex(1, &arg) == FAILURE) {
WRONG_PARAM_COUNT;
}
convert_to_string_ex(arg);
if (php_check_open_basedir((*arg)->value.str.val)) {
RETURN_FALSE;
}
dirp = emalloc(sizeof(php_dir));
dirp->dir = VCWD_OPENDIR((*arg)->value.str.val);
#ifdef PHP_WIN32
if (!dirp->dir || dirp->dir->finished) {
if (dirp->dir) {
closedir(dirp->dir);
}
#else
if (!dirp->dir) {
#endif
efree(dirp);
php_error(E_WARNING, "OpenDir: %s (errno %d)", strerror(errno), errno);
RETURN_FALSE;
}
dirp->id = zend_list_insert(dirp,le_dirp);
php_set_default_dir(dirp->id DIRLS_CC);
if (createobject) {
object_init_ex(return_value, dir_class_entry_ptr);
add_property_stringl(return_value, "path", (*arg)->value.str.val, (*arg)->value.str.len, 1);
add_property_resource(return_value, "handle", dirp->id);
zend_list_addref(dirp->id);
} else {
RETURN_RESOURCE(dirp->id);
}
}
/* }}} */
/* {{{ proto int opendir(string path)
Open a directory and return a dir_handle */
PHP_FUNCTION(opendir)
{
_php_do_opendir(INTERNAL_FUNCTION_PARAM_PASSTHRU,0);
}
/* }}} */
/* {{{ proto class dir(string directory)
Directory class with properties, handle and class and methods read, rewind and close */
PHP_FUNCTION(getdir)
{
_php_do_opendir(INTERNAL_FUNCTION_PARAM_PASSTHRU,1);
}
/* }}} */
/* {{{ proto void closedir([int dir_handle])
Close directory connection identified by the dir_handle */
PHP_FUNCTION(closedir)
{
pval **id, **tmp, *myself;
php_dir *dirp;
DIRLS_FETCH();
FETCH_DIRP();
zend_list_delete(dirp->id);
if (dirp->id == DIRG(default_dir)) {
php_set_default_dir(-1 DIRLS_CC);
}
}
/* }}} */
#if defined(HAVE_CHROOT) && !defined(ZTS)
/* {{{ proto int chroot(string directory)
Change root directory */
PHP_FUNCTION(chroot)
{
pval **arg;
int ret;
if (ZEND_NUM_ARGS() != 1 || zend_get_parameters_ex(1, &arg) == FAILURE) {
WRONG_PARAM_COUNT;
}
convert_to_string_ex(arg);
ret = chroot((*arg)->value.str.val);
if (ret != 0) {
php_error(E_WARNING, "chroot: %s (errno %d)", strerror(errno), errno);
RETURN_FALSE;
}
ret = chdir("/");
if (ret != 0) {
php_error(E_WARNING, "chdir: %s (errno %d)", strerror(errno), errno);
RETURN_FALSE;
}
RETURN_TRUE;
}
/* }}} */
#endif
/* {{{ proto int chdir(string directory)
Change the current directory */
PHP_FUNCTION(chdir)
{
pval **arg;
int ret;
PLS_FETCH();
if (ZEND_NUM_ARGS() != 1 || zend_get_parameters_ex(1, &arg) == FAILURE) {
WRONG_PARAM_COUNT;
}
convert_to_string_ex(arg);
if (PG(safe_mode) && !php_checkuid((*arg)->value.str.val, NULL, CHECKUID_ALLOW_ONLY_DIR)) {
RETURN_FALSE;
}
ret = VCWD_CHDIR((*arg)->value.str.val);
if (ret != 0) {
php_error(E_WARNING, "ChDir: %s (errno %d)", strerror(errno), errno);
RETURN_FALSE;
}
RETURN_TRUE;
}
/* }}} */
/* {{{ proto string getcwd(void)
Gets the current directory */
PHP_FUNCTION(getcwd)
{
char path[MAXPATHLEN];
char *ret=NULL;
if (ZEND_NUM_ARGS() != 0) {
WRONG_PARAM_COUNT;
}
#if HAVE_GETCWD
ret = VCWD_GETCWD(path, MAXPATHLEN);
#elif HAVE_GETWD
ret = VCWD_GETWD(path);
/*
* #warning is not ANSI C
* #else
* #warning no proper getcwd support for your site
*/
#endif
if (ret) {
RETURN_STRING(path,1);
} else {
RETURN_FALSE;
}
}
/* }}} */
/* {{{ proto void rewinddir([int dir_handle])
Rewind dir_handle back to the start */
PHP_FUNCTION(rewinddir)
{
pval **id, **tmp, *myself;
php_dir *dirp;
DIRLS_FETCH();
FETCH_DIRP();
rewinddir(dirp->dir);
}
/* }}} */
/* {{{ proto string readdir([int dir_handle])
Read directory entry from dir_handle */
PHP_NAMED_FUNCTION(php_if_readdir)
{
pval **id, **tmp, *myself;
php_dir *dirp;
char entry[sizeof(struct dirent)+MAXPATHLEN];
struct dirent *result = (struct dirent *)&entry; /* patch for libc5 readdir problems */
DIRLS_FETCH();
FETCH_DIRP();
if (php_readdir_r(dirp->dir, (struct dirent *) entry, &result) == 0 && result) {
RETURN_STRINGL(result->d_name, strlen(result->d_name), 1);
}
RETURN_FALSE;
}
/* ArchiveWriter::__construct {{{
*
*/
ZEND_METHOD(ArchiveWriter, __construct)
{
archive_file_t *arch = NULL;
int resource_id;
zval *this = getThis();
const char *error_string = NULL;
char *filename;
long error_num, filename_len, result, format=0, compression=0;
zend_error_handling error_handling;
zend_replace_error_handling(EH_THROW, ce_ArchiveException, &error_handling TSRMLS_CC);
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|ll", &filename, &filename_len, &format, &compression) == FAILURE) {
zend_restore_error_handling(&error_handling TSRMLS_CC);
return;
}
#if PHP_API_VERSION < 20100412
if (PG(safe_mode) && (!php_checkuid(filename, NULL, CHECKUID_CHECK_FILE_AND_DIR))) {
zend_restore_error_handling(&error_handling TSRMLS_CC);
return;
}
#endif
if (php_check_open_basedir(filename TSRMLS_CC)) {
zend_restore_error_handling(&error_handling TSRMLS_CC);
return;
}
arch = (archive_file_t *) emalloc(sizeof(archive_file_t));
arch->stream = NULL;
ALLOC_HASHTABLE(arch->entries);
zend_hash_init(arch->entries, 10, NULL, _archive_entries_hash_dtor, 0);
arch->mode = PHP_ARCHIVE_WRITE_MODE;
arch->buf = emalloc(PHP_ARCHIVE_BUF_LEN + 1);
arch->filename = estrndup(filename, filename_len);
arch->arch = archive_write_new();
switch (compression) {
case PHP_ARCHIVE_COMPRESSION_GZIP:
if (archive_write_add_filter_gzip(arch->arch) != ARCHIVE_OK) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Gzip compression is not supported in this build");
zend_restore_error_handling(&error_handling TSRMLS_CC);
return;
}
break;
case PHP_ARCHIVE_COMPRESSION_BZIP2:
if (archive_write_add_filter_bzip2(arch->arch) != ARCHIVE_OK) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Bzip2 compression is not supported in this build");
zend_restore_error_handling(&error_handling TSRMLS_CC);
return;
}
break;
case 0: /* default value */
case PHP_ARCHIVE_COMPRESSION_NONE:
/* always supported */
break;
default:
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unsupported compression type %ld", compression);
zend_restore_error_handling(&error_handling TSRMLS_CC);
return;
break;
}
switch (format) {
case 0: /* default value */
case PHP_ARCHIVE_FORMAT_TAR:
case PHP_ARCHIVE_FORMAT_PAX_RESTRICTED:
archive_write_set_format_pax_restricted(arch->arch);
break;
case PHP_ARCHIVE_FORMAT_PAX:
archive_write_set_format_pax(arch->arch);
break;
case PHP_ARCHIVE_FORMAT_CPIO:
archive_write_set_format_cpio(arch->arch);
break;
case PHP_ARCHIVE_FORMAT_SHAR:
archive_write_set_format_shar(arch->arch);
break;
case PHP_ARCHIVE_FORMAT_USTAR:
archive_write_set_format_ustar(arch->arch);
break;
default:
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unsupported archive format: %ld", format);
zend_restore_error_handling(&error_handling TSRMLS_CC);
return;
break;
}
archive_write_set_bytes_per_block(arch->arch, DEFAULT_BYTES_PER_BLOCK);
result = archive_write_open(arch->arch, arch, _archive_open_clbk, _archive_write_clbk, _archive_close_clbk);
/* do not pad the last block */
archive_write_set_bytes_in_last_block(arch->arch, 1);
if (result) {
error_num = archive_errno(arch->arch);
error_string = archive_error_string(arch->arch);
efree(arch->filename);
efree(arch->buf);
efree(arch);
if (error_num && error_string) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed to open file %s for writing: error #%ld, %s", filename, error_num, error_string);
}
else {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed to open file %s for writing: unknown error %ld", filename, result);
}
zend_restore_error_handling(&error_handling TSRMLS_CC);
return;
}
resource_id = zend_list_insert(arch,le_archive);
add_property_resource(this, "fd", resource_id);
zend_restore_error_handling(&error_handling TSRMLS_CC);
return;
}
/* {{{ PHP_MINFO_FUNCTION
*/
PHP_MINFO_FUNCTION(luxio)
{
php_info_print_table_start();
php_info_print_table_header(2, "luxio support", "enabled");
php_info_print_table_end();
}
/* }}} */
// {{{ _php_luxio_create()
static void _php_luxio_create(zval *obj TSRMLS_DC)
{
Lux::IO::Btree *bt = new Lux::IO::Btree(Lux::IO::CLUSTER);
int ret = zend_list_insert(bt, le_luxio);
add_property_resource(obj, "luxio", ret);
}
// }}}
// {{{ _php_luxio_connection_resource_dtor()
static void _php_luxio_resource_dtor(zend_rsrc_list_entry *rsrc TSRMLS_DC) {
((Lux::IO::Btree *)rsrc->ptr)->close();
delete ((Lux::IO::Btree *)rsrc->ptr);
}
// }}}
// {{{ _php_luxio_get_instance()
static void *_php_luxio_get_instance(zval *obj TSRMLS_DC) {
zval **tmp;
luxio_objprop_get_p(obj, "luxio", tmp, 0);
PHPAPI void php_variant_to_pval(VARIANT *var_arg, pval *pval_arg, int persistent, int codepage)
{
switch(var_arg->vt & ~VT_BYREF)
{
case VT_EMPTY:
var_uninit(pval_arg);
break;
case VT_UI1:
if(var_arg->vt & VT_BYREF)
pval_arg->value.lval = (long)*(var_arg->pbVal);
else
pval_arg->value.lval = (long) var_arg->bVal;
pval_arg->type = IS_LONG;
break;
case VT_I2:
if(var_arg->vt & VT_BYREF)
pval_arg->value.lval = (long )*(var_arg->piVal);
else
pval_arg->value.lval = (long) var_arg->iVal;
pval_arg->type = IS_LONG;
break;
case VT_I4:
if(var_arg->vt & VT_BYREF)
pval_arg->value.lval = *(var_arg->plVal);
else
pval_arg->value.lval = var_arg->lVal;
pval_arg->type = IS_LONG;
break;
case VT_R4:
if(var_arg->vt & VT_BYREF)
pval_arg->value.dval = (double)*(var_arg->pfltVal);
else
pval_arg->value.dval = (double) var_arg->fltVal;
pval_arg->type = IS_DOUBLE;
break;
case VT_R8:
if(var_arg->vt & VT_BYREF)
pval_arg->value.dval = *(var_arg->pdblVal);
else
pval_arg->value.dval = var_arg->dblVal;
pval_arg->type = IS_DOUBLE;
break;
case VT_DECIMAL:
{
OLECHAR *unicode_str;
switch(VarBstrFromDec(&var_arg->decVal, LOCALE_SYSTEM_DEFAULT, 0, &unicode_str))
{
case S_OK:
pval_arg->value.str.val = php_OLECHAR_to_char(unicode_str, &pval_arg->value.str.len, persistent, codepage);
pval_arg->type = IS_STRING;
break;
default:
php_error(E_WARNING, "Error converting DECIMAL value to PHP floating point");
break;
}
}
break;
case VT_CY:
if(var_arg->vt & VT_BYREF)
VarR8FromCy(var_arg->cyVal, &(pval_arg->value.dval));
else
VarR8FromCy(*(var_arg->pcyVal), &(pval_arg->value.dval));
pval_arg->type = IS_DOUBLE;
break;
case VT_BOOL:
if (var_arg->vt & VT_BYREF)
if (*(var_arg->pboolVal) & 0xFFFF)
pval_arg->value.lval = 1;
else
pval_arg->value.lval = 0;
else
if (var_arg->boolVal & 0xFFFF)
pval_arg->value.lval = 1;
else
pval_arg->value.lval = 0;
pval_arg->type = IS_BOOL;
break;
case VT_NULL:
case VT_VOID:
pval_arg->type = IS_NULL;
break;
case VT_VARIANT:
php_variant_to_pval(var_arg->pvarVal, pval_arg, persistent, codepage);
break;
case VT_BSTR:
if (pval_arg->is_ref == 0 || (var_arg->vt & VT_BYREF) != VT_BYREF) {
pval_arg->value.str.val = php_OLECHAR_to_char(var_arg->bstrVal, &pval_arg->value.str.len, persistent, codepage);
SysFreeString(var_arg->bstrVal);
} else {
pval_arg->value.str.val = php_OLECHAR_to_char(*(var_arg->pbstrVal), &pval_arg->value.str.len, persistent, codepage);
SysFreeString(*(var_arg->pbstrVal));
efree(var_arg->pbstrVal);
}
pval_arg->type = IS_STRING;
break;
case VT_DATE: {
SYSTEMTIME wintime;
struct tm phptime;
VariantTimeToSystemTime(var_arg->date, &wintime);
phptime.tm_year = wintime.wYear - 1900;
phptime.tm_mon = wintime.wMonth - 1;
phptime.tm_mday = wintime.wDay;
phptime.tm_hour = wintime.wHour;
phptime.tm_min = wintime.wMinute;
phptime.tm_sec = wintime.wSecond;
phptime.tm_isdst = -1;
tzset();
pval_arg->value.lval = mktime(&phptime);
pval_arg->type = IS_LONG;
}
break;
case VT_DISPATCH: {
pval *handle;
i_dispatch *obj;
pval_arg->type=IS_OBJECT;
pval_arg->value.obj.ce = &com_class_entry;
pval_arg->value.obj.properties = (HashTable *) emalloc(sizeof(HashTable));
pval_arg->is_ref=1;
pval_arg->refcount=1;
zend_hash_init(pval_arg->value.obj.properties, 0, NULL, ZVAL_PTR_DTOR, 0);
ALLOC_ZVAL(handle);
obj = emalloc(sizeof(i_dispatch));
php_COM_set(obj, var_arg->pdispVal, TRUE);
handle->type = IS_LONG;
handle->value.lval = zend_list_insert(obj, php_COM_get_le_idispatch());
pval_copy_constructor(handle);
INIT_PZVAL(handle);
zend_hash_index_update(pval_arg->value.obj.properties, 0, &handle, sizeof(pval *), NULL);
}
break;
case VT_UNKNOWN:
//wtf ??
var_arg->pdispVal->lpVtbl->Release(var_arg->pdispVal);
/* break missing intentionally */
case VT_I1:
if(var_arg->vt & VT_BYREF)
pval_arg->value.lval = (long)*(var_arg->pcVal);
else
pval_arg->value.lval = (long) var_arg->cVal;
pval_arg->type = IS_LONG;
break;
case VT_UI2:
if(var_arg->vt & VT_BYREF)
pval_arg->value.lval = (long)*(var_arg->puiVal);
else
pval_arg->value.lval = (long) var_arg->uiVal;
pval_arg->type = IS_LONG;
break;
case VT_UI4:
if(var_arg->vt & VT_BYREF)
pval_arg->value.lval = (long)*(var_arg->pulVal);
else
pval_arg->value.lval = (long) var_arg->ulVal;
pval_arg->type = IS_LONG;
break;
case VT_INT:
if(var_arg->vt & VT_BYREF)
pval_arg->value.lval = (long)*(var_arg->pintVal);
else
pval_arg->value.lval = (long) var_arg->intVal;
pval_arg->type = IS_LONG;
break;
case VT_UINT:
if(var_arg->vt & VT_BYREF)
pval_arg->value.lval = (long)*(var_arg->puintVal);
else
pval_arg->value.lval = (long) var_arg->uintVal;
pval_arg->type = IS_LONG;
break;
default:
php_error(E_WARNING,"Unsupported variant type: %d (0x%X)", var_arg->vt, var_arg->vt);
var_reset(pval_arg);
break;
}
}