/* 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;
}
static void php_do_chown(INTERNAL_FUNCTION_PARAMETERS, int do_lchown)
{
zval **filename, **user;
int ret;
uid_t uid;
if (ZEND_NUM_ARGS()!=2 || zend_get_parameters_ex(2, &filename, &user)==FAILURE) {
WRONG_PARAM_COUNT;
}
convert_to_string_ex(filename);
if (Z_TYPE_PP(user) == IS_STRING) {
#if defined(ZTS) && defined(_SC_GETPW_R_SIZE_MAX) && defined(HAVE_GETPWNAM_R)
struct passwd pw;
struct passwd *retpwptr = NULL;
long pwbuflen = sysconf(_SC_GETPW_R_SIZE_MAX);
char *pwbuf;
if (pwbuflen < 1) {
RETURN_FALSE;
}
pwbuf = emalloc(pwbuflen);
if (getpwnam_r(Z_STRVAL_PP(user), &pw, pwbuf, pwbuflen, &retpwptr) != 0 || retpwptr == NULL) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to find uid for %s", Z_STRVAL_PP(user));
efree(pwbuf);
RETURN_FALSE;
}
efree(pwbuf);
uid = pw.pw_uid;
#else
struct passwd *pw = getpwnam(Z_STRVAL_PP(user));
if (!pw) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to find uid for %s", Z_STRVAL_PP(user));
RETURN_FALSE;
}
uid = pw->pw_uid;
#endif
} else {
convert_to_long_ex(user);
uid = Z_LVAL_PP(user);
}
if (PG(safe_mode) &&(!php_checkuid(Z_STRVAL_PP(filename), NULL, CHECKUID_ALLOW_FILE_NOT_EXISTS))) {
RETURN_FALSE;
}
/* Check the basedir */
if (php_check_open_basedir(Z_STRVAL_PP(filename) TSRMLS_CC)) {
RETURN_FALSE;
}
if (do_lchown) {
#if HAVE_LCHOWN
ret = VCWD_LCHOWN(Z_STRVAL_PP(filename), uid, -1);
#endif
} else {
ret = VCWD_CHOWN(Z_STRVAL_PP(filename), uid, -1);
}
if (ret == -1) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", strerror(errno));
RETURN_FALSE;
}
}
static void php_do_chgrp(INTERNAL_FUNCTION_PARAMETERS, int do_lchgrp)
{
zval **filename, **group;
gid_t gid;
int ret;
if (ZEND_NUM_ARGS()!=2 || zend_get_parameters_ex(2, &filename, &group)==FAILURE) {
WRONG_PARAM_COUNT;
}
convert_to_string_ex(filename);
if (Z_TYPE_PP(group) == IS_STRING) {
#if defined(ZTS) && defined(HAVE_GETGRNAM_R) && defined(_SC_GETGR_R_SIZE_MAX)
struct group gr;
struct group *retgrptr;
long grbuflen = sysconf(_SC_GETGR_R_SIZE_MAX);
char *grbuf;
if (grbuflen < 1) {
RETURN_FALSE;
}
grbuf = emalloc(grbuflen);
if (getgrnam_r(Z_STRVAL_PP(group), &gr, grbuf, grbuflen, &retgrptr) != 0 || retgrptr == NULL) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to find gid for %s", Z_STRVAL_PP(group));
efree(grbuf);
RETURN_FALSE;
}
efree(grbuf);
gid = gr.gr_gid;
#else
struct group *gr = getgrnam(Z_STRVAL_PP(group));
if (!gr) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to find gid for %s", Z_STRVAL_PP(group));
RETURN_FALSE;
}
gid = gr->gr_gid;
#endif
} else {
convert_to_long_ex(group);
gid = Z_LVAL_PP(group);
}
if (PG(safe_mode) &&(!php_checkuid(Z_STRVAL_PP(filename), NULL, CHECKUID_ALLOW_FILE_NOT_EXISTS))) {
RETURN_FALSE;
}
/* Check the basedir */
if (php_check_open_basedir(Z_STRVAL_PP(filename) TSRMLS_CC)) {
RETURN_FALSE;
}
if (do_lchgrp) {
#if HAVE_LCHOWN
ret = VCWD_LCHOWN(Z_STRVAL_PP(filename), -1, gid);
#endif
} else {
ret = VCWD_CHOWN(Z_STRVAL_PP(filename), -1, gid);
}
if (ret == -1) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", strerror(errno));
RETURN_FALSE;
}
RETURN_TRUE;
}
/* {{{ php_oci_lob_import()
Import LOB contents from the given file */
int php_oci_lob_import (php_oci_descriptor *descriptor, char *filename)
{
int fp;
ub4 loblen;
OCILobLocator *lob = (OCILobLocator *)descriptor->descriptor;
php_oci_connection *connection = descriptor->connection;
char buf[8192];
ub4 offset = 1;
sword errstatus;
#if (PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION > 3) || (PHP_MAJOR_VERSION > 5)
/* Safe mode has been removed in PHP 5.4 */
if (php_check_open_basedir(filename)) {
#else
if ((PG(safe_mode) && (!php_checkuid(filename, NULL, CHECKUID_CHECK_FILE_AND_DIR))) || php_check_open_basedir(filename)) {
#endif
return 1;
}
if ((fp = VCWD_OPEN(filename, O_RDONLY|O_BINARY)) == -1) {
php_error_docref(NULL, E_WARNING, "Can't open file %s", filename);
return 1;
}
while ((loblen = read(fp, &buf, sizeof(buf))) > 0) {
PHP_OCI_CALL_RETURN(errstatus,
OCILobWrite,
(
connection->svc,
connection->err,
lob,
&loblen,
offset,
(dvoid *) &buf,
loblen,
OCI_ONE_PIECE,
(dvoid *)0,
(OCICallbackLobWrite) 0,
(ub2) descriptor->charset_id,
(ub1) descriptor->charset_form
)
);
if (errstatus != OCI_SUCCESS) {
connection->errcode = php_oci_error(connection->err, errstatus);
PHP_OCI_HANDLE_ERROR(connection, connection->errcode);
close(fp);
return 1;
} else {
connection->errcode = 0; /* retain backwards compat with OCI8 1.4 */
}
offset += loblen;
}
close(fp);
return 0;
}
/* }}} */
/* {{{ php_oci_lob_append()
Append data to the end of the LOB */
int php_oci_lob_append (php_oci_descriptor *descriptor_dest, php_oci_descriptor *descriptor_from)
{
php_oci_connection *connection = descriptor_dest->connection;
OCILobLocator *lob_dest = descriptor_dest->descriptor;
OCILobLocator *lob_from = descriptor_from->descriptor;
ub4 dest_len, from_len;
sword errstatus;
if (php_oci_lob_get_length(descriptor_dest, &dest_len)) {
return 1;
}
if (php_oci_lob_get_length(descriptor_from, &from_len)) {
return 1;
}
if (from_len <= 0) {
return 0;
}
PHP_OCI_CALL_RETURN(errstatus, OCILobAppend, (connection->svc, connection->err, lob_dest, lob_from));
if (errstatus != OCI_SUCCESS) {
connection->errcode = php_oci_error(connection->err, errstatus);
PHP_OCI_HANDLE_ERROR(connection, connection->errcode);
return 1;
}
connection->errcode = 0; /* retain backwards compat with OCI8 1.4 */
return 0;
}
/* 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;
}
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;
}
