/* {{{ Gets absolute filename of the file. Returns null if format is virtual Filename can be passed with or without format indicator */ char *php_imagick_get_absolute_filename(char *filename, int filename_len TSRMLS_DC) { int chr_pos = php_imagick_format_indicator(filename, filename_len TSRMLS_CC); if (chr_pos == -1) { /* There was no recognised format in the filename, try to access as is */ return expand_filepath(filename, NULL TSRMLS_CC); } /* the was a format but is it virtual?? */ if (php_imagick_is_virtual_format(filename, filename_len TSRMLS_CC)) { /* virtual format has no filename */ return NULL; } return expand_filepath(filename + chr_pos + 1, NULL TSRMLS_CC); }
static char *make_filename_safe(const char *filename) { if (*filename && memcmp(filename, ":memory:", sizeof(":memory:"))) { char *fullpath = expand_filepath(filename, NULL); if (!fullpath) { return NULL; } if (php_check_open_basedir(fullpath)) { efree(fullpath); return NULL; } return fullpath; } return estrdup(filename); }
/* {{{ proto bool GmagickDraw::setFont(string font_name) Sets the fully-sepecified font to use when annotating with text. */ PHP_METHOD(gmagickdraw, setfont) { php_gmagickdraw_object *internd; char *font, *absolute; int font_len, error = 0; /* Parse parameters given to function */ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &font, &font_len) == FAILURE) { return; } /* Check that no empty string is passed */ if (font_len == 0) { GMAGICK_THROW_EXCEPTION_WITH_MESSAGE(GMAGICKDRAW_CLASS, "Can not set empty font", 2); } internd = (php_gmagickdraw_object *)zend_object_store_get_object(getThis() TSRMLS_CC); /* And if it wasn't */ if (!check_configured_font(font, font_len TSRMLS_CC)) { if (!(absolute = expand_filepath(font, NULL TSRMLS_CC))) { GMAGICK_THROW_EXCEPTION_WITH_MESSAGE(GMAGICKDRAW_CLASS, "Unable to set font", 2); } /* Do a safe-mode check for the font */ GMAGICK_SAFE_MODE_CHECK(absolute, error); GMAGICKDRAW_CHECK_READ_OR_WRITE_ERROR(internd, absolute, error, GMAGICK_FREE_FILENAME); if (VCWD_ACCESS(absolute, F_OK|R_OK)) { zend_throw_exception_ex(php_gmagickdraw_exception_class_entry, 2 TSRMLS_CC, "The given font is not found in the GraphicsMagick configuration and the file (%s) is not accessible", absolute); efree(absolute); return; } DrawSetFont(internd->drawing_wand, absolute); efree(absolute); } else { DrawSetFont(internd->drawing_wand, font); } GMAGICK_CHAIN_METHOD; }
/* _xmlreader_get_valid_file_path and _xmlreader_get_relaxNG should be made a common function in libxml extension as code is common to a few xml extensions */ char *_xmlreader_get_valid_file_path(char *source, char *resolved_path, int resolved_path_len ) { xmlURI *uri; xmlChar *escsource; char *file_dest; int isFileUri = 0; uri = xmlCreateURI(); escsource = xmlURIEscapeStr((xmlChar *)source, (xmlChar *)":"); xmlParseURIReference(uri, (const char *)escsource); xmlFree(escsource); if (uri->scheme != NULL) { /* absolute file uris - libxml only supports localhost or empty host */ if (strncasecmp(source, "file:///",8) == 0) { isFileUri = 1; #ifdef PHP_WIN32 source += 8; #else source += 7; #endif } else if (strncasecmp(source, "file://localhost/",17) == 0) { isFileUri = 1; #ifdef PHP_WIN32 source += 17; #else source += 16; #endif } } file_dest = source; if ((uri->scheme == NULL || isFileUri)) { if (!VCWD_REALPATH(source, resolved_path) && !expand_filepath(source, resolved_path)) { xmlFreeURI(uri); return NULL; } file_dest = resolved_path; } xmlFreeURI(uri); return file_dest; }
static php_vedis_t * php_vedis_new(char *storage, int storage_len, zend_bool is_persistent TSRMLS_DC) { php_vedis_t *vedis; char *filepath = NULL, *stragepath = NULL; vedis = pecalloc(1, sizeof(php_vedis_t), is_persistent); if (!storage || storage_len <= 0) { stragepath = NULL; } else if (strcmp(storage, ":mem:") != 0) { if (!(filepath = expand_filepath(storage, NULL TSRMLS_CC))) { pefree(vedis, is_persistent); return NULL; } stragepath = filepath; } else { stragepath = storage; } if (vedis_open(&(vedis->store), stragepath) != VEDIS_OK) { if (filepath) { efree(filepath); } pefree(vedis, is_persistent); return NULL; } if (filepath) { efree(filepath); } vedis->storage = storage; vedis->is_persistent = is_persistent; vedis->pid = getpid(); return vedis; }
void zend_accel_blacklist_load(zend_blacklist *blacklist, char *filename) { char buf[MAXPATHLEN+1], real_path[MAXPATHLEN+1]; FILE *fp; int path_length; TSRMLS_FETCH(); if ((fp=fopen(filename, "r"))==NULL) { zend_accel_error(ACCEL_LOG_WARNING, "Cannot load blacklist file: %s\n", filename); return; } zend_accel_error(ACCEL_LOG_DEBUG,"Loading blacklist file: '%s'", filename); memset(buf, 0, sizeof(buf)); memset(real_path, 0, sizeof(real_path)); while (fgets(buf, MAXPATHLEN, fp)!=NULL) { char *path_dup, *pbuf; path_length = strlen(buf); if (path_length > 0 && buf[path_length-1]=='\n') { buf[--path_length] = 0; if (path_length > 0 && buf[path_length-1]=='\r') { buf[--path_length] = 0; } } /* Strip ctrl-m prefix */ pbuf = &buf[0]; while(*pbuf == '\r') { *pbuf++ = 0; path_length--; } /* strip \" */ if( pbuf[0] == '\"' && pbuf[path_length-1]== '\"' ){ *pbuf++ = 0; path_length-=2; } if (path_length==0) { continue; } path_dup = zend_strndup(pbuf, path_length); expand_filepath(path_dup, real_path TSRMLS_CC); path_length = strlen(real_path); free(path_dup); zend_accel_blacklist_allocate(blacklist); blacklist->entries[blacklist->pos].path_length = path_length; blacklist->entries[blacklist->pos].path = (char *) malloc(path_length+1); if (!blacklist->entries[blacklist->pos].path) { zend_accel_error(ACCEL_LOG_ERROR, "malloc() failed\n"); return; } blacklist->entries[blacklist->pos].id = blacklist->pos; memcpy(blacklist->entries[blacklist->pos].path, real_path, path_length+1); blacklist->pos++; } fclose(fp); zend_accel_blacklist_update_regexp(blacklist); }
/* {{{ php_check_specific_open_basedir When open_basedir is not NULL, check if the given filename is located in open_basedir. Returns -1 if error or not in the open_basedir, else 0. When open_basedir is NULL, always return 0. */ PHPAPI int php_check_specific_open_basedir(const char *basedir, const char *path) { char resolved_name[MAXPATHLEN]; char resolved_basedir[MAXPATHLEN]; char local_open_basedir[MAXPATHLEN]; char path_tmp[MAXPATHLEN]; char *path_file; int resolved_basedir_len; int resolved_name_len; int path_len; int nesting_level = 0; /* Special case basedir==".": Use script-directory */ if (strcmp(basedir, ".") || !VCWD_GETCWD(local_open_basedir, MAXPATHLEN)) { /* Else use the unmodified path */ strlcpy(local_open_basedir, basedir, sizeof(local_open_basedir)); } path_len = (int)strlen(path); if (path_len > (MAXPATHLEN - 1)) { /* empty and too long paths are invalid */ return -1; } /* normalize and expand path */ if (expand_filepath(path, resolved_name) == NULL) { return -1; } path_len = (int)strlen(resolved_name); memcpy(path_tmp, resolved_name, path_len + 1); /* safe */ while (VCWD_REALPATH(path_tmp, resolved_name) == NULL) { #if defined(PHP_WIN32) || defined(HAVE_SYMLINK) #if defined(PHP_WIN32) if (EG(windows_version_info).dwMajorVersion > 5) { #endif if (nesting_level == 0) { int ret; char buf[MAXPATHLEN]; ret = php_sys_readlink(path_tmp, buf, MAXPATHLEN - 1); if (ret < 0) { /* not a broken symlink, move along.. */ } else { /* put the real path into the path buffer */ memcpy(path_tmp, buf, ret); path_tmp[ret] = '\0'; } } #if defined(PHP_WIN32) } #endif #endif #if defined(PHP_WIN32) || defined(NETWARE) path_file = strrchr(path_tmp, DEFAULT_SLASH); if (!path_file) { path_file = strrchr(path_tmp, '/'); } #else path_file = strrchr(path_tmp, DEFAULT_SLASH); #endif if (!path_file) { /* none of the path components exist. definitely not in open_basedir.. */ return -1; } else { path_len = path_file - path_tmp + 1; #if defined(PHP_WIN32) || defined(NETWARE) if (path_len > 1 && path_tmp[path_len - 2] == ':') { if (path_len != 3) { return -1; } /* this is c:\ */ path_tmp[path_len] = '\0'; } else { path_tmp[path_len - 1] = '\0'; } #else path_tmp[path_len - 1] = '\0'; #endif } nesting_level++; } /* Resolve open_basedir to resolved_basedir */ if (expand_filepath(local_open_basedir, resolved_basedir) != NULL) { int basedir_len = (int)strlen(basedir); /* Handler for basedirs that end with a / */ resolved_basedir_len = (int)strlen(resolved_basedir); #if defined(PHP_WIN32) || defined(NETWARE) if (basedir[basedir_len - 1] == PHP_DIR_SEPARATOR || basedir[basedir_len - 1] == '/') { #else if (basedir[basedir_len - 1] == PHP_DIR_SEPARATOR) { #endif if (resolved_basedir[resolved_basedir_len - 1] != PHP_DIR_SEPARATOR) { resolved_basedir[resolved_basedir_len] = PHP_DIR_SEPARATOR; resolved_basedir[++resolved_basedir_len] = '\0'; } } else { resolved_basedir[resolved_basedir_len++] = PHP_DIR_SEPARATOR; resolved_basedir[resolved_basedir_len] = '\0'; } resolved_name_len = (int)strlen(resolved_name); if (path_tmp[path_len - 1] == PHP_DIR_SEPARATOR) { if (resolved_name[resolved_name_len - 1] != PHP_DIR_SEPARATOR) { resolved_name[resolved_name_len] = PHP_DIR_SEPARATOR; resolved_name[++resolved_name_len] = '\0'; } } /* Check the path */ #if defined(PHP_WIN32) || defined(NETWARE) if (strncasecmp(resolved_basedir, resolved_name, resolved_basedir_len) == 0) { #else if (strncmp(resolved_basedir, resolved_name, resolved_basedir_len) == 0) { #endif if (resolved_name_len > resolved_basedir_len && resolved_name[resolved_basedir_len - 1] != PHP_DIR_SEPARATOR) { return -1; } else { /* File is in the right directory */ return 0; } } else { /* /openbasedir/ and /openbasedir are the same directory */ if (resolved_basedir_len == (resolved_name_len + 1) && resolved_basedir[resolved_basedir_len - 1] == PHP_DIR_SEPARATOR) { #if defined(PHP_WIN32) || defined(NETWARE) if (strncasecmp(resolved_basedir, resolved_name, resolved_name_len) == 0) { #else if (strncmp(resolved_basedir, resolved_name, resolved_name_len) == 0) { #endif return 0; } } return -1; } } else { /* Unable to resolve the real path, return -1 */ return -1; } } /* }}} */ PHPAPI int php_check_open_basedir(const char *path) { return php_check_open_basedir_ex(path, 1); } /* {{{ php_check_open_basedir */ PHPAPI int php_check_open_basedir_ex(const char *path, int warn) { /* Only check when open_basedir is available */ if (PG(open_basedir) && *PG(open_basedir)) { char *pathbuf; char *ptr; char *end; /* Check if the path is too long so we can give a more useful error * message. */ if (strlen(path) > (MAXPATHLEN - 1)) { php_error_docref(NULL, E_WARNING, "File name is longer than the maximum allowed path length on this platform (%d): %s", MAXPATHLEN, path); errno = EINVAL; return -1; } pathbuf = estrdup(PG(open_basedir)); ptr = pathbuf; while (ptr && *ptr) { end = strchr(ptr, DEFAULT_DIR_SEPARATOR); if (end != NULL) { *end = '\0'; end++; } if (php_check_specific_open_basedir(ptr, path) == 0) { efree(pathbuf); return 0; } ptr = end; } if (warn) { php_error_docref(NULL, E_WARNING, "open_basedir restriction in effect. File(%s) is not within the allowed path(s): (%s)", path, PG(open_basedir)); } efree(pathbuf); errno = EPERM; /* we deny permission to open it */ return -1; } /* Nothing to check... */ return 0; } /* }}} */ /* {{{ php_fopen_and_set_opened_path */ static FILE *php_fopen_and_set_opened_path(const char *path, const char *mode, zend_string **opened_path) { FILE *fp; if (php_check_open_basedir((char *)path)) { return NULL; } fp = VCWD_FOPEN(path, mode); if (fp && opened_path) { //TODO :avoid reallocation char *tmp = expand_filepath_with_mode(path, NULL, NULL, 0, CWD_EXPAND); if (tmp) { *opened_path = zend_string_init(tmp, strlen(tmp), 0); efree(tmp); } } return fp; }
int php_imagick_read_image_using_php_streams(php_imagick_object *intern, int type, char *filename, int filename_len TSRMLS_DC) { php_stream *stream; MagickBooleanType status; FILE *fp; #if ZEND_MODULE_API_NO > 20060613 zend_error_handling error_handling; #endif #if ZEND_MODULE_API_NO > 20060613 zend_replace_error_handling(EH_THROW, php_imagick_exception_class_entry, &error_handling TSRMLS_CC); #else php_set_error_handling(EH_THROW, php_imagick_exception_class_entry TSRMLS_CC); #endif stream = php_stream_open_wrapper(filename, "rb", (ENFORCE_SAFE_MODE|IGNORE_PATH) & ~REPORT_ERRORS, NULL); if (!stream) { goto return_error; } if (php_stream_can_cast(stream, PHP_STREAM_AS_STDIO|PHP_STREAM_CAST_INTERNAL) == FAILURE) { goto return_error; } if (php_stream_cast(stream, PHP_STREAM_AS_STDIO|PHP_STREAM_CAST_INTERNAL, (void*)&fp, 0) == FAILURE) { goto return_error; } #if ZEND_MODULE_API_NO > 20060613 zend_restore_error_handling(&error_handling TSRMLS_CC); #else php_set_error_handling(EH_NORMAL, NULL TSRMLS_CC); #endif if (type == 1) { status = MagickReadImageFile(intern->magick_wand, fp); } else { status = MagickPingImageFile(intern->magick_wand, fp); } if (status == MagickFalse) { php_stream_close(stream); return IMAGICK_READ_WRITE_UNDERLYING_LIBRARY; } if (php_stream_is(stream, PHP_STREAM_IS_STDIO)) { char *absolute = expand_filepath(filename, NULL TSRMLS_CC); MagickSetImageFilename(intern->magick_wand, absolute); efree(absolute); } else { /* Set to empty filename, otherwise it will point to MAGICK_TEMP/magick-XXXXX */ MagickSetImageFilename(intern->magick_wand, ""); } php_stream_close(stream); if (status == MagickFalse) { return IMAGICK_READ_WRITE_UNDERLYING_LIBRARY; } IMAGICK_CORRECT_ITERATOR_POSITION(intern); return IMAGICK_READ_WRITE_NO_ERROR; return_error: #if ZEND_MODULE_API_NO > 20060613 zend_restore_error_handling(&error_handling TSRMLS_CC); #else php_set_error_handling(EH_NORMAL, NULL TSRMLS_CC); #endif if (stream) php_stream_close(stream); return IMAGICK_READ_WRITE_UNDERLYING_LIBRARY; }
/* {{{ php_init_config */ int php_init_config(void) { char *php_ini_file_name = NULL; char *php_ini_search_path = NULL; int php_ini_scanned_path_len; char *open_basedir; int free_ini_search_path = 0; zend_file_handle fh; zend_hash_init(&configuration_hash, 8, NULL, config_zval_dtor, 1); if (sapi_module.ini_defaults) { sapi_module.ini_defaults(&configuration_hash); } zend_llist_init(&extension_lists.engine, sizeof(char *), (llist_dtor_func_t) free_estring, 1); zend_llist_init(&extension_lists.functions, sizeof(char *), (llist_dtor_func_t) free_estring, 1); open_basedir = PG(open_basedir); if (sapi_module.php_ini_path_override) { php_ini_file_name = sapi_module.php_ini_path_override; php_ini_search_path = sapi_module.php_ini_path_override; free_ini_search_path = 0; } else if (!sapi_module.php_ini_ignore) { int search_path_size; char *default_location; char *env_location; static const char paths_separator[] = { ZEND_PATHS_SEPARATOR, 0 }; #ifdef PHP_WIN32 char *reg_location; char phprc_path[MAXPATHLEN]; #endif env_location = getenv("PHPRC"); #ifdef PHP_WIN32 if (!env_location) { char dummybuf; int size; SetLastError(0); /*If the given bugger is not large enough to hold the data, the return value is the buffer size, in characters, required to hold the string and its terminating null character. We use this return value to alloc the final buffer. */ size = GetEnvironmentVariableA("PHPRC", &dummybuf, 0); if (GetLastError() == ERROR_ENVVAR_NOT_FOUND) { /* The environment variable doesn't exist. */ env_location = ""; } else { if (size == 0) { env_location = ""; } else { size = GetEnvironmentVariableA("PHPRC", phprc_path, size); if (size == 0) { env_location = ""; } else { env_location = phprc_path; } } } } #else if (!env_location) { env_location = ""; } #endif /* * Prepare search path */ search_path_size = MAXPATHLEN * 4 + (int)strlen(env_location) + 3 + 1; php_ini_search_path = (char *) emalloc(search_path_size); free_ini_search_path = 1; php_ini_search_path[0] = 0; /* Add environment location */ if (env_location[0]) { if (*php_ini_search_path) { strlcat(php_ini_search_path, paths_separator, search_path_size); } strlcat(php_ini_search_path, env_location, search_path_size); php_ini_file_name = env_location; } #ifdef PHP_WIN32 /* Add registry location */ reg_location = GetIniPathFromRegistry(); if (reg_location != NULL) { if (*php_ini_search_path) { strlcat(php_ini_search_path, paths_separator, search_path_size); } strlcat(php_ini_search_path, reg_location, search_path_size); efree(reg_location); } #endif /* Add cwd (not with CLI) */ if (!sapi_module.php_ini_ignore_cwd) { if (*php_ini_search_path) { strlcat(php_ini_search_path, paths_separator, search_path_size); } strlcat(php_ini_search_path, ".", search_path_size); } if (PG(php_binary)) { char *separator_location, *binary_location; binary_location = estrdup(PG(php_binary)); separator_location = strrchr(binary_location, DEFAULT_SLASH); if (separator_location && separator_location != binary_location) { *(separator_location) = 0; } if (*php_ini_search_path) { strlcat(php_ini_search_path, paths_separator, search_path_size); } strlcat(php_ini_search_path, binary_location, search_path_size); efree(binary_location); } /* Add default location */ #ifdef PHP_WIN32 default_location = (char *) emalloc(MAXPATHLEN + 1); if (0 < GetWindowsDirectory(default_location, MAXPATHLEN)) { if (*php_ini_search_path) { strlcat(php_ini_search_path, paths_separator, search_path_size); } strlcat(php_ini_search_path, default_location, search_path_size); } /* For people running under terminal services, GetWindowsDirectory will * return their personal Windows directory, so lets add the system * windows directory too */ if (0 < GetSystemWindowsDirectory(default_location, MAXPATHLEN)) { if (*php_ini_search_path) { strlcat(php_ini_search_path, paths_separator, search_path_size); } strlcat(php_ini_search_path, default_location, search_path_size); } efree(default_location); #else default_location = PHP_CONFIG_FILE_PATH; if (*php_ini_search_path) { strlcat(php_ini_search_path, paths_separator, search_path_size); } strlcat(php_ini_search_path, default_location, search_path_size); #endif } PG(open_basedir) = NULL; /* * Find and open actual ini file */ memset(&fh, 0, sizeof(fh)); /* If SAPI does not want to ignore all ini files OR an overriding file/path is given. * This allows disabling scanning for ini files in the PHP_CONFIG_FILE_SCAN_DIR but still * load an optional ini file. */ if (!sapi_module.php_ini_ignore || sapi_module.php_ini_path_override) { /* Check if php_ini_file_name is a file and can be opened */ if (php_ini_file_name && php_ini_file_name[0]) { zend_stat_t statbuf; if (!VCWD_STAT(php_ini_file_name, &statbuf)) { if (!((statbuf.st_mode & S_IFMT) == S_IFDIR)) { fh.handle.fp = VCWD_FOPEN(php_ini_file_name, "r"); if (fh.handle.fp) { fh.filename = php_ini_opened_path = expand_filepath(php_ini_file_name, NULL); } } } } /* Otherwise search for php-%sapi-module-name%.ini file in search path */ if (!fh.handle.fp) { const char *fmt = "php-%s.ini"; char *ini_fname; spprintf(&ini_fname, 0, fmt, sapi_module.name); fh.handle.fp = php_fopen_with_path(ini_fname, "r", php_ini_search_path, &php_ini_opened_path); efree(ini_fname); if (fh.handle.fp) { fh.filename = php_ini_opened_path; } } /* If still no ini file found, search for php.ini file in search path */ if (!fh.handle.fp) { fh.handle.fp = php_fopen_with_path("php.ini", "r", php_ini_search_path, &php_ini_opened_path); if (fh.handle.fp) { fh.filename = php_ini_opened_path; } } } if (free_ini_search_path) { efree(php_ini_search_path); } PG(open_basedir) = open_basedir; if (fh.handle.fp) { fh.type = ZEND_HANDLE_FP; RESET_ACTIVE_INI_HASH(); zend_parse_ini_file(&fh, 1, ZEND_INI_SCANNER_NORMAL, (zend_ini_parser_cb_t) php_ini_parser_cb, &configuration_hash); { zval tmp; ZVAL_NEW_STR(&tmp, zend_string_init(fh.filename, strlen(fh.filename), 1)); zend_hash_str_update(&configuration_hash, "cfg_file_path", sizeof("cfg_file_path")-1, &tmp); if (php_ini_opened_path) { efree(php_ini_opened_path); } php_ini_opened_path = zend_strndup(Z_STRVAL(tmp), Z_STRLEN(tmp)); } } /* Check for PHP_INI_SCAN_DIR environment variable to override/set config file scan directory */ php_ini_scanned_path = getenv("PHP_INI_SCAN_DIR"); if (!php_ini_scanned_path) { /* Or fall back using possible --with-config-file-scan-dir setting (defaults to empty string!) */ php_ini_scanned_path = PHP_CONFIG_FILE_SCAN_DIR; } php_ini_scanned_path_len = (int)strlen(php_ini_scanned_path); /* Scan and parse any .ini files found in scan path if path not empty. */ if (!sapi_module.php_ini_ignore && php_ini_scanned_path_len) { struct dirent **namelist; int ndir, i; zend_stat_t sb; char ini_file[MAXPATHLEN]; char *p; zend_file_handle fh2; zend_llist scanned_ini_list; zend_llist_element *element; int l, total_l = 0; char *bufpath, *debpath, *endpath; int lenpath; zend_llist_init(&scanned_ini_list, sizeof(char *), (llist_dtor_func_t) free_estring, 1); memset(&fh2, 0, sizeof(fh2)); bufpath = estrdup(php_ini_scanned_path); for (debpath = bufpath ; debpath ; debpath=endpath) { endpath = strchr(debpath, DEFAULT_DIR_SEPARATOR); if (endpath) { *(endpath++) = 0; } if (!debpath[0]) { /* empty string means default builtin value to allow "/foo/phd.d:" or ":/foo/php.d" */ debpath = PHP_CONFIG_FILE_SCAN_DIR; } lenpath = (int)strlen(debpath); if (lenpath > 0 && (ndir = php_scandir(debpath, &namelist, 0, php_alphasort)) > 0) { for (i = 0; i < ndir; i++) { /* check for any file with .ini extension */ if (!(p = strrchr(namelist[i]->d_name, '.')) || (p && strcmp(p, ".ini"))) { free(namelist[i]); continue; } /* Reset active ini section */ RESET_ACTIVE_INI_HASH(); if (IS_SLASH(debpath[lenpath - 1])) { snprintf(ini_file, MAXPATHLEN, "%s%s", debpath, namelist[i]->d_name); } else { snprintf(ini_file, MAXPATHLEN, "%s%c%s", debpath, DEFAULT_SLASH, namelist[i]->d_name); } if (VCWD_STAT(ini_file, &sb) == 0) { if (S_ISREG(sb.st_mode)) { if ((fh2.handle.fp = VCWD_FOPEN(ini_file, "r"))) { fh2.filename = ini_file; fh2.type = ZEND_HANDLE_FP; if (zend_parse_ini_file(&fh2, 1, ZEND_INI_SCANNER_NORMAL, (zend_ini_parser_cb_t) php_ini_parser_cb, &configuration_hash) == SUCCESS) { /* Here, add it to the list of ini files read */ l = (int)strlen(ini_file); total_l += l + 2; p = estrndup(ini_file, l); zend_llist_add_element(&scanned_ini_list, &p); } } } } free(namelist[i]); } free(namelist); } } efree(bufpath); if (total_l) { int php_ini_scanned_files_len = (php_ini_scanned_files) ? (int)strlen(php_ini_scanned_files) + 1 : 0; php_ini_scanned_files = (char *) realloc(php_ini_scanned_files, php_ini_scanned_files_len + total_l + 1); if (!php_ini_scanned_files_len) { *php_ini_scanned_files = '\0'; } total_l += php_ini_scanned_files_len; for (element = scanned_ini_list.head; element; element = element->next) { if (php_ini_scanned_files_len) { strlcat(php_ini_scanned_files, ",\n", total_l); } strlcat(php_ini_scanned_files, *(char **)element->data, total_l); strlcat(php_ini_scanned_files, element->next ? ",\n" : "\n", total_l); } } zend_llist_destroy(&scanned_ini_list); } else { /* Make sure an empty php_ini_scanned_path ends up as NULL */ php_ini_scanned_path = NULL; } if (sapi_module.ini_entries) { /* Reset active ini section */ RESET_ACTIVE_INI_HASH(); zend_parse_ini_string(sapi_module.ini_entries, 1, ZEND_INI_SCANNER_NORMAL, (zend_ini_parser_cb_t) php_ini_parser_cb, &configuration_hash); } return SUCCESS; }
//----------------------------------------------------------------------------- // name: start_vm() // desc: ... //----------------------------------------------------------------------------- t_CKBOOL miniAudicle::start_vm() { char buffer[1024]; time_t t; // allocate status buffers // allocate alternating buffers for VM status messages num_status_bufs = 4; status_bufs = new Chuck_VM_Status * [num_status_bufs]; for( size_t i = 0; i < num_status_bufs; i++ ) status_bufs[i] = new Chuck_VM_Status; status_bufs_read = 0; status_bufs_write = 0; // clear shred management structures last_result.clear(); while( !otf_docids.empty() ) otf_docids.pop(); map< t_CKUINT, vector< t_CKUINT > * >::iterator iter = documents.begin(), end = documents.end(); for( ; iter != end; iter++ ) iter->second->clear(); shreds.clear(); // clear the class name existence map class_names->clear(); time(&t); strncpy( buffer, ctime(&t), 24 ); buffer[24] = '\0'; // log EM_log( CK_LOG_SYSTEM, "-------( %s )-------", buffer ); EM_log( CK_LOG_SYSTEM, "starting chuck virtual machine..." ); // push log EM_pushlog(); if( m_chuck == NULL ) { // log EM_log( CK_LOG_INFO, "allocating VM..." ); t_CKBOOL enable_audio = vm_options.enable_audio; t_CKBOOL vm_halt = FALSE; t_CKBOOL force_srate = TRUE; t_CKUINT srate = vm_options.srate; t_CKUINT buffer_size = vm_options.buffer_size; t_CKUINT num_buffers = NUM_BUFFERS_DEFAULT; t_CKUINT dac = vm_options.dac; t_CKUINT adc = vm_options.adc; t_CKBOOL set_priority = FALSE; t_CKBOOL block = vm_options.enable_block; t_CKUINT output_channels = vm_options.num_outputs; t_CKUINT input_channels = vm_options.num_inputs; t_CKUINT adaptive_size = 0; // lets make up some magic numbers... vm_sleep_time = vm_options.buffer_size * 1000000 / vm_options.srate; vm_sleep_max = 20; vm_status_timeouts_max = vm_options.buffer_size / 100; vm_status_timeouts = 0; // check buffer size // buffer_size = next_power_2( buffer_size-1 ); // audio, boost if( !set_priority && !block ) priority = priority_low; if( !set_priority && !enable_audio ) priority = 0x7fffffff; // set priority // Chuck_VM::our_priority = priority; // set watchdog #ifdef __MACOSX_CORE__ g_do_watchdog = TRUE; g_watchdog_timeout = .5; #else g_do_watchdog = FALSE; #endif std::list<std::string> library_paths = vm_options.library_paths; std::list<std::string> named_chugins = vm_options.named_chugins; // normalize paths for(std::list<std::string>::iterator i = library_paths.begin(); i != library_paths.end(); i++) *i = expand_filepath(*i); for(std::list<std::string>::iterator j = named_chugins.begin(); j != named_chugins.end(); j++) *j = expand_filepath(*j); m_chuck = new ChucK(); m_chuck->setParam(CHUCK_PARAM_SAMPLE_RATE, srate); m_chuck->setParam(CHUCK_PARAM_INPUT_CHANNELS, input_channels); m_chuck->setParam(CHUCK_PARAM_OUTPUT_CHANNELS, output_channels); m_chuck->setParam(CHUCK_PARAM_VM_ADAPTIVE, adaptive_size); m_chuck->setParam(CHUCK_PARAM_VM_HALT, vm_halt); m_chuck->setParam(CHUCK_PARAM_USER_CHUGINS, named_chugins); m_chuck->setParam(CHUCK_PARAM_USER_CHUGIN_DIRECTORIES, library_paths); if( !m_chuck->init() ) { fprintf( stderr, "[chuck]: failed to init chuck engine\n" ); // pop EM_poplog(); return FALSE; } // allocate the vm - needs the type system vm = m_chuck->vm(); //--------------------------- AUDIO I/O SETUP --------------------------------- // push EM_pushlog(); // log EM_log( CK_LOG_SYSTEM, "probing '%s' audio subsystem...", enable_audio ? "real-time" : "fake-time" ); ChuckAudio::m_dac_n = dac; ChuckAudio::m_adc_n = adc; // probe / init (this shouldn't start audio yet... // moved here 1.3.1.2; to main ge: 1.3.5.3) if( !ChuckAudio::initialize( output_channels, input_channels, srate, buffer_size, num_buffers, audio_cb, m_chuck, force_srate ) ) { EM_log( CK_LOG_SYSTEM, "cannot initialize audio device (use --silent/-s for non-realtime)" ); // pop EM_poplog(); // done return FALSE; } // log EM_log( CK_LOG_SYSTEM, "real-time audio: %s", enable_audio ? "YES" : "NO" ); EM_log( CK_LOG_SYSTEM, "mode: %s", block ? "BLOCKING" : "CALLBACK" ); EM_log( CK_LOG_SYSTEM, "sample rate: %ld", srate ); EM_log( CK_LOG_SYSTEM, "buffer size: %ld", buffer_size ); if( enable_audio ) { EM_log( CK_LOG_SYSTEM, "num buffers: %ld", num_buffers ); EM_log( CK_LOG_SYSTEM, "adc: %ld dac: %d", adc, dac ); EM_log( CK_LOG_SYSTEM, "adaptive block processing: %ld", adaptive_size > 1 ? adaptive_size : 0 ); } EM_log( CK_LOG_SYSTEM, "channels in: %ld out: %ld", input_channels, output_channels ); // pop EM_poplog(); // allocate the compiler compiler = m_chuck->compiler(); #ifdef __MA_IMPORT_MAUI__ // import api init_maui( compiler->env() ); #endif for(list<t_CKBOOL (*)(Chuck_Env *)>::iterator i = vm_options.query_funcs.begin(); i != vm_options.query_funcs.end(); i++) (*i)( compiler->env() ); if(!ChuckAudio::start()) { EM_log( CK_LOG_SYSTEM, "error starting audio (use --silent/-s for non-realtime)" ); // pop EM_poplog(); // done return FALSE; } // pop log EM_poplog(); EM_log( CK_LOG_SYSTEM, "running audio" ); } vm_on = TRUE; // pop EM_poplog(); return vm_on; }
PHPAPI int php_checkuid_ex(const char *filename, const char *fopen_mode, int mode, int flags) { struct stat sb; int ret, nofile=0; long uid=0L, gid=0L, duid=0L, dgid=0L; char path[MAXPATHLEN]; char *s, filenamecopy[MAXPATHLEN]; TSRMLS_FETCH(); path[0] = '\0'; if (!filename) { return 0; /* path must be provided */ } if (strlcpy(filenamecopy, filename, MAXPATHLEN)>=MAXPATHLEN) { return 0; } filename=(char *)&filenamecopy; if (fopen_mode) { if (fopen_mode[0] == 'r') { mode = CHECKUID_DISALLOW_FILE_NOT_EXISTS; } else { mode = CHECKUID_CHECK_FILE_AND_DIR; } } /* First we see if the file is owned by the same user... * If that fails, passthrough and check directory... */ if (mode != CHECKUID_ALLOW_ONLY_DIR) { #if HAVE_BROKEN_GETCWD char ftest[MAXPATHLEN]; strcpy(ftest, filename); if (VCWD_GETCWD(ftest, sizeof(ftest)) == NULL) { strcpy(path, filename); } else #endif expand_filepath(filename, path TSRMLS_CC); ret = VCWD_STAT(path, &sb); if (ret < 0) { if (mode == CHECKUID_DISALLOW_FILE_NOT_EXISTS) { if ((flags & CHECKUID_NO_ERRORS) == 0) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to access %s", filename); } return 0; } else if (mode == CHECKUID_ALLOW_FILE_NOT_EXISTS) { if ((flags & CHECKUID_NO_ERRORS) == 0) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to access %s", filename); } return 1; } nofile = 1; } else { uid = sb.st_uid; gid = sb.st_gid; if (uid == php_getuid()) { return 1; } else if (PG(safe_mode_gid) && gid == php_getgid()) { return 1; } } /* Trim off filename */ if ((s = strrchr(path, DEFAULT_SLASH))) { if (*(s + 1) == '\0' && s != path) { /* make sure that the / is not the last character */ *s = '\0'; s = strrchr(path, DEFAULT_SLASH); } if (s) { if (s == path) { path[1] = '\0'; } else { *s = '\0'; } } } } else { /* CHECKUID_ALLOW_ONLY_DIR */ s = strrchr(filename, DEFAULT_SLASH); if (s == filename) { /* root dir */ path[0] = DEFAULT_SLASH; path[1] = '\0'; } else if (s && *(s + 1) != '\0') { /* make sure that the / is not the last character */ *s = '\0'; VCWD_REALPATH(filename, path); *s = DEFAULT_SLASH; } else { /* Under Solaris, getcwd() can fail if there are no * read permissions on a component of the path, even * though it has the required x permissions */ path[0] = '.'; path[1] = '\0'; VCWD_GETCWD(path, sizeof(path)); } } /* end CHECKUID_ALLOW_ONLY_DIR */ if (mode != CHECKUID_ALLOW_ONLY_FILE) { /* check directory */ ret = VCWD_STAT(path, &sb); if (ret < 0) { if ((flags & CHECKUID_NO_ERRORS) == 0) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to access %s", filename); } return 0; } duid = sb.st_uid; dgid = sb.st_gid; if (duid == php_getuid()) { return 1; } else if (PG(safe_mode_gid) && dgid == php_getgid()) { return 1; } else { if (SG(rfc1867_uploaded_files)) { if (zend_hash_exists(SG(rfc1867_uploaded_files), (char *) filename, strlen(filename)+1)) { return 1; } } } } if (mode == CHECKUID_ALLOW_ONLY_DIR) { uid = duid; gid = dgid; if (s) { *s = 0; } } if (nofile) { uid = duid; gid = dgid; filename = path; } if ((flags & CHECKUID_NO_ERRORS) == 0) { if (PG(safe_mode_gid)) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "SAFE MODE Restriction in effect. The script whose uid/gid is %ld/%ld is not allowed to access %s owned by uid/gid %ld/%ld", php_getuid(), php_getgid(), filename, uid, gid); } else { php_error_docref(NULL TSRMLS_CC, E_WARNING, "SAFE MODE Restriction in effect. The script whose uid is %ld is not allowed to access %s owned by uid %ld", php_getuid(), filename, uid); } } return 0; }
/* {{{ proto object ffmpeg_movie(string filename) Constructor for ffmpeg_movie objects */ FFMPEG_PHP_CONSTRUCTOR(ffmpeg_movie, __construct) { int hashkey_length = 0, filename_len; char *filename = NULL, *fullpath = NULL, *hashkey = NULL; zend_bool persistent = 0; ff_movie_context *ffmovie_ctx = NULL; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|b", &filename, &filename_len, &persistent) != SUCCESS) { return; } if (persistent && !INI_BOOL("ffmpeg.allow_persistent")) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "Persistent movies have been disabled in php.ini"); RETURN_FALSE; } if (persistent) { zend_rsrc_list_entry *le; /* resolve the fully-qualified path name to use as the hash key */ fullpath = expand_filepath(filename, NULL TSRMLS_CC); hashkey_length = sizeof("ffmpeg-php_")-1 + filename_len; hashkey = (char *) emalloc(hashkey_length+1); snprintf(hashkey, hashkey_length, "ffmpeg-php_%s", filename); /* do we have an existing persistent movie? */ if (SUCCESS == zend_hash_find(&EG(persistent_list), hashkey, hashkey_length+1, (void**)&le)) { int type; if (Z_TYPE_P(le) != le_ffmpeg_pmovie) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed to retrieve persistent resource"); efree(hashkey); RETURN_FALSE; } ffmovie_ctx = (ff_movie_context*)le->ptr; /* sanity check to ensure that the resource is still a valid * regular resource number */ if (zend_list_find(ffmovie_ctx->rsrc_id, &type) == ffmovie_ctx) { /* add a reference to the persistent movie */ zend_list_addref(ffmovie_ctx->rsrc_id); } else { //php_error_docref(NULL TSRMLS_CC, E_ERROR, //"Not a valid persistent movie resource"); ffmovie_ctx->rsrc_id = ZEND_REGISTER_RESOURCE(NULL, ffmovie_ctx, le_ffmpeg_pmovie); } } else { /* no existing persistant movie, create one */ zend_rsrc_list_entry new_le; ffmovie_ctx = _php_alloc_ffmovie_ctx(1); if (_php_open_movie_file(ffmovie_ctx, filename)) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "Can't open movie file %s", filename); ZVAL_BOOL(getThis(), 0); RETURN_FALSE; } Z_TYPE(new_le) = le_ffmpeg_pmovie; new_le.ptr = ffmovie_ctx; if (FAILURE == zend_hash_update(&EG(persistent_list), hashkey, hashkey_length+1, (void *)&new_le, sizeof(zend_rsrc_list_entry), NULL)) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed to register persistent resource"); RETURN_FALSE; } ffmovie_ctx->rsrc_id = ZEND_REGISTER_RESOURCE(NULL, ffmovie_ctx, le_ffmpeg_pmovie); } } else { ffmovie_ctx = _php_alloc_ffmovie_ctx(0); if (_php_open_movie_file(ffmovie_ctx, filename)) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "Can't open movie file %s", filename); ZVAL_BOOL(getThis(), 0); RETURN_FALSE; } /* pass NULL for resource result since we're not returning the resource directly, but adding it to the returned object. */ ffmovie_ctx->rsrc_id = ZEND_REGISTER_RESOURCE(NULL, ffmovie_ctx, le_ffmpeg_movie); } object_init_ex(getThis(), ffmpeg_movie_class_entry_ptr); add_property_resource(getThis(), "ffmpeg_movie", ffmovie_ctx->rsrc_id); if (fullpath) { efree(fullpath); } if (hashkey) { efree(hashkey); } }
//----------------------------------------------------------------------------- // name: start_vm() // desc: ... //----------------------------------------------------------------------------- t_CKBOOL miniAudicle::start_vm() { char buffer[1024]; time_t t; // allocate status buffers // allocate alternating buffers for VM status messages num_status_bufs = 4; status_bufs = new Chuck_VM_Status * [num_status_bufs]; for( size_t i = 0; i < num_status_bufs; i++ ) status_bufs[i] = new Chuck_VM_Status; status_bufs_read = 0; status_bufs_write = 0; // clear shred management structures last_result.clear(); while( !otf_docids.empty() ) otf_docids.pop(); map< t_CKUINT, vector< t_CKUINT > * >::iterator iter = documents.begin(), end = documents.end(); for( ; iter != end; iter++ ) iter->second->clear(); shreds.clear(); // clear the class name existence map class_names->clear(); time(&t); strncpy( buffer, ctime(&t), 24 ); buffer[24] = '\0'; // log EM_log( CK_LOG_SYSTEM, "-------( %s )-------", buffer ); EM_log( CK_LOG_SYSTEM, "starting chuck virtual machine..." ); // push log EM_pushlog(); if( vm == NULL ) { // log EM_log( CK_LOG_INFO, "allocating VM..." ); t_CKBOOL enable_audio = vm_options.enable_audio; t_CKBOOL vm_halt = FALSE; t_CKUINT srate = vm_options.srate; t_CKUINT buffer_size = vm_options.buffer_size; t_CKUINT num_buffers = NUM_BUFFERS_DEFAULT; t_CKUINT dac = vm_options.dac; t_CKUINT adc = vm_options.adc; t_CKBOOL set_priority = FALSE; t_CKBOOL block = vm_options.enable_block; t_CKUINT output_channels = vm_options.num_outputs; t_CKUINT input_channels = vm_options.num_inputs; // lets make up some magic numbers... vm_sleep_time = vm_options.buffer_size * 1000000 / vm_options.srate; vm_sleep_max = 20; vm_status_timeouts_max = vm_options.buffer_size / 100; vm_status_timeouts = 0; // check buffer size // buffer_size = next_power_2( buffer_size-1 ); // audio, boost if( !set_priority && !block ) priority = priority_low; if( !set_priority && !enable_audio ) priority = 0x7fffffff; // set priority Chuck_VM::our_priority = priority; // set watchdog #ifdef __MACOSX_CORE__ g_do_watchdog = TRUE; g_watchdog_timeout = .5; #else g_do_watchdog = FALSE; #endif // allocate the vm - needs the type system vm = g_vm = new Chuck_VM; if( !vm->initialize( enable_audio, vm_halt, srate, buffer_size, num_buffers, dac, adc, output_channels, input_channels, block ) ) { fprintf( stderr, "[chuck]: %s\n", vm->last_error() ); // pop EM_poplog(); return FALSE; } // log EM_log( CK_LOG_INFO, "allocating compiler..." ); // allocate the compiler g_compiler = compiler = new Chuck_Compiler; std::list<std::string> library_paths = vm_options.library_paths; std::list<std::string> named_chugins = vm_options.named_chugins; // normalize paths for(std::list<std::string>::iterator i = library_paths.begin(); i != library_paths.end(); i++) *i = expand_filepath(*i); for(std::list<std::string>::iterator j = named_chugins.begin(); j != named_chugins.end(); j++) *j = expand_filepath(*j); // initialize the compiler compiler->initialize( vm, library_paths, named_chugins ); // enable dump compiler->emitter->dump = FALSE; // set auto depend compiler->set_auto_depend( FALSE ); // vm synthesis subsystem - needs the type system if( !vm->initialize_synthesis() ) { fprintf( stderr, "[chuck]: %s\n", vm->last_error() ); // pop EM_poplog(); return FALSE; } #ifdef __MA_IMPORT_MAUI__ // import api init_maui( compiler->env ); #endif for(list<t_CKBOOL (*)(Chuck_Env *)>::iterator i = vm_options.query_funcs.begin(); i != vm_options.query_funcs.end(); i++) (*i)( compiler->env ); // reset the parser reset_parse(); Chuck_VM_Code * code = NULL; Chuck_VM_Shred * shred = NULL; // whether or not chug should be enabled (added 1.3.0.0) EM_log( CK_LOG_SEVERE, "pre-loading ChucK libs..." ); EM_pushlog(); // iterate over list of ck files that the compiler found for( std::list<std::string>::iterator fck = compiler->m_cklibs_to_preload.begin(); fck != compiler->m_cklibs_to_preload.end(); fck++) { // the filename std::string filename = *fck; // log EM_log( CK_LOG_SEVERE, "preloading '%s'...", filename.c_str() ); // push indent EM_pushlog(); // SPENCERTODO: what to do for full path std::string full_path = filename; // parse, type-check, and emit if( compiler->go( filename, NULL, NULL, full_path ) ) { // TODO: how to compilation handle? //return 1; // get the code code = compiler->output(); // name it - TODO? // code->name += string(argv[i]); // spork it shred = vm->spork( code, NULL ); } // pop indent EM_poplog(); } // clear the list of chuck files to preload compiler->m_cklibs_to_preload.clear(); // pop log EM_poplog(); // load user namespace compiler->env->load_user_namespace(); // start the vm handler threads #ifndef __PLATFORM_WIN32__ pthread_create( &vm_tid, NULL, vm_cb, NULL ); #else vm_tid = CreateThread( NULL, 0, (LPTHREAD_START_ROUTINE)vm_cb, NULL, 0, 0 ); #endif } // check it if( !g_forked && vm_options.enable_network ) { // start tcp server g_sock = ck_tcp_create( 1 ); if( !g_sock || !ck_bind( g_sock, g_port ) || !ck_listen( g_sock, 10 ) ) { fprintf( stderr, "[chuck]: cannot bind to tcp port %li...\n", g_port ); ck_close( g_sock ); g_sock = NULL; } else { #ifndef __PLATFORM_WIN32__ pthread_create( &otf_tid, NULL, otf_cb, NULL ); #else otf_tid = CreateThread( NULL, 0, (LPTHREAD_START_ROUTINE)otf_cb, NULL, 0, 0 ); #endif } g_forked = TRUE; } vm_on = TRUE; // pop EM_poplog(); return vm_on; }
/* {{{ proto object ffmpeg_movie(string filename) Constructor for ffmpeg_movie objects */ FFMPEG_PHP_CONSTRUCTOR(ffmpeg_movie, __construct) { int persistent = 0, hashkey_length = 0; char *filename = NULL, *fullpath = NULL, *hashkey = NULL; zval ***argv; ff_movie_context *ffmovie_ctx = NULL; /* retrieve arguments */ argv = (zval ***) safe_emalloc(sizeof(zval **), ZEND_NUM_ARGS(), 0); if (zend_get_parameters_array_ex(ZEND_NUM_ARGS(), argv) != SUCCESS) { efree(argv); php_error_docref(NULL TSRMLS_CC, E_ERROR, "Error parsing arguments"); } switch (ZEND_NUM_ARGS()) { case 2: convert_to_boolean_ex(argv[1]); if (! INI_BOOL("ffmpeg.allow_persistent") && Z_LVAL_PP(argv[1])) { zend_error(E_WARNING, "Persistent movies have been disabled in php.ini"); break; } persistent = Z_LVAL_PP(argv[1]); /* fallthru */ case 1: convert_to_string_ex(argv[0]); filename = Z_STRVAL_PP(argv[0]); break; default: WRONG_PARAM_COUNT; } if (persistent) { list_entry *le; /* resolve the fully-qualified path name to use as the hash key */ fullpath = expand_filepath(filename, NULL TSRMLS_CC); hashkey_length = sizeof("ffmpeg-php_")-1 + strlen(SAFE_STRING(filename)); hashkey = (char *) emalloc(hashkey_length+1); snprintf(hashkey, hashkey_length, "ffmpeg-php_%s", SAFE_STRING(filename)); /* do we have an existing persistent movie? */ if (SUCCESS == zend_hash_find(&EG(persistent_list), hashkey, hashkey_length+1, (void**)&le)) { int type; if (Z_TYPE_P(le) != le_ffmpeg_pmovie) { php_error_docref(NULL TSRMLS_CC, E_ERROR, "Failed to retrieve persistent resource"); } ffmovie_ctx = (ff_movie_context*)le->ptr; /* sanity check to ensure that the resource is still a valid * regular resource number */ if (zend_list_find(ffmovie_ctx->rsrc_id, &type) == ffmovie_ctx) { /* add a reference to the persistent movie */ zend_list_addref(ffmovie_ctx->rsrc_id); } else { //php_error_docref(NULL TSRMLS_CC, E_ERROR, //"Not a valid persistent movie resource"); ffmovie_ctx->rsrc_id = ZEND_REGISTER_RESOURCE(NULL, ffmovie_ctx, le_ffmpeg_pmovie); } } else { /* no existing persistant movie, create one */ list_entry new_le; ffmovie_ctx = _php_alloc_ffmovie_ctx(1); if (_php_open_movie_file(ffmovie_ctx, filename)) { zend_error(E_WARNING, "Can't open movie file %s", filename); efree(argv); ZVAL_BOOL(getThis(), 0); RETURN_FALSE; } Z_TYPE(new_le) = le_ffmpeg_pmovie; new_le.ptr = ffmovie_ctx; if (FAILURE == zend_hash_update(&EG(persistent_list), hashkey, hashkey_length+1, (void *)&new_le, sizeof(list_entry), NULL)) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed to register persistent resource"); } ffmovie_ctx->rsrc_id = ZEND_REGISTER_RESOURCE(NULL, ffmovie_ctx, le_ffmpeg_pmovie); } } else { ffmovie_ctx = _php_alloc_ffmovie_ctx(0); if (_php_open_movie_file(ffmovie_ctx, Z_STRVAL_PP(argv[0]))) { zend_error(E_WARNING, "Can't open movie file %s", Z_STRVAL_PP(argv[0])); efree(argv); ZVAL_BOOL(getThis(), 0); RETURN_FALSE; } /* pass NULL for resource result since we're not returning the resource directly, but adding it to the returned object. */ ffmovie_ctx->rsrc_id = ZEND_REGISTER_RESOURCE(NULL, ffmovie_ctx, le_ffmpeg_movie); } object_init_ex(getThis(), ffmpeg_movie_class_entry_ptr); add_property_resource(getThis(), "ffmpeg_movie", ffmovie_ctx->rsrc_id); efree(argv); if (fullpath) { efree(fullpath); } if (hashkey) { efree(hashkey); } }