PHP 4.0 NEWS
|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
-?? ??? 2000, Version 4.0.3-dev
+05 Oct 2000, Version 4.0.3
+- Added support for trans sid under Win32 (Daniel)
+- IPv6 support in fopen (Stig Venaas)
+- Added the shmop extension. It allows more general ways of shared memory
+ access. (thanks to Ilia Alshanestky <iliaa@home.com> and Slava Poliakov
+ <slavapl@mailandnews.com> (Derick)
- Added the ability for CURLOPT_POSTFIELDS to accept an associative array of
HTTP POST variables and values. (Sterling)
- Added the CURLOPT_HTTPHEADER option to curl_setopt(). (Sterling)
--- /dev/null
+
+/*
+ * If C9X_INLINE_SEMANTICS is already defined here,
+ * we assume the user does not want GCC inline semantics,
+ * but compiles this file always.
+ */
+
+#ifndef C9X_INLINE_SEMANTICS
+
+#define C9X_INLINE_SEMANTICS
+
+#include "zend.h"
+
+#include "zend_execute.h"
+#include "zend_operators.h"
+
+#endif
+++ /dev/null
-#ifndef _INCLUDED_IMAP_H
-#define _INCLUDED_IMAP_H
-
-#if COMPILE_DL
-#undef HAVE_IMAP
-#define HAVE_IMAP 1
-#endif
-
-#if HAVE_IMAP
-
-#ifndef PHP_WIN32
-#include "build-defs.h"
-#endif
-
-/* Functions accessable to PHP */
-extern zend_module_entry imap_module_entry;
-#define imap_module_ptr &imap_module_entry
-
-extern PHP_MINIT_FUNCTION(imap);
-extern PHP_RINIT_FUNCTION(imap);
-extern PHP_RSHUTDOWN_FUNCTION(imap);
-PHP_MINFO_FUNCTION(imap);
-PHP_FUNCTION(imap_open);
-PHP_FUNCTION(imap_popen);
-PHP_FUNCTION(imap_reopen);
-PHP_FUNCTION(imap_num_msg);
-PHP_FUNCTION(imap_num_recent);
-PHP_FUNCTION(imap_headers);
-PHP_FUNCTION(imap_headerinfo);
-PHP_FUNCTION(imap_rfc822_parse_headers);
-PHP_FUNCTION(imap_body);
-PHP_FUNCTION(imap_fetchstructure);
-PHP_FUNCTION(imap_fetchbody);
-PHP_FUNCTION(imap_expunge);
-PHP_FUNCTION(imap_delete);
-PHP_FUNCTION(imap_undelete);
-PHP_FUNCTION(imap_check);
-PHP_FUNCTION(imap_close);
-PHP_FUNCTION(imap_mail_copy);
-PHP_FUNCTION(imap_mail_move);
-PHP_FUNCTION(imap_createmailbox);
-PHP_FUNCTION(imap_renamemailbox);
-PHP_FUNCTION(imap_deletemailbox);
-PHP_FUNCTION(imap_listmailbox);
-PHP_FUNCTION(imap_scanmailbox);
-PHP_FUNCTION(imap_subscribe);
-PHP_FUNCTION(imap_unsubscribe);
-PHP_FUNCTION(imap_append);
-PHP_FUNCTION(imap_ping);
-PHP_FUNCTION(imap_base64);
-PHP_FUNCTION(imap_qprint);
-PHP_FUNCTION(imap_8bit);
-PHP_FUNCTION(imap_binary);
-PHP_FUNCTION(imap_mailboxmsginfo);
-PHP_FUNCTION(imap_rfc822_write_address);
-PHP_FUNCTION(imap_rfc822_parse_adrlist);
-PHP_FUNCTION(imap_setflag_full);
-PHP_FUNCTION(imap_clearflag_full);
-PHP_FUNCTION(imap_sort);
-PHP_FUNCTION(imap_fetchheader);
-PHP_FUNCTION(imap_fetchtext);
-PHP_FUNCTION(imap_uid);
-PHP_FUNCTION(imap_msgno);
-PHP_FUNCTION(imap_list);
-PHP_FUNCTION(imap_list_full);
-PHP_FUNCTION(imap_listscan);
-PHP_FUNCTION(imap_lsub);
-PHP_FUNCTION(imap_lsub_full);
-PHP_FUNCTION(imap_create);
-PHP_FUNCTION(imap_rename);
-PHP_FUNCTION(imap_status);
-PHP_FUNCTION(imap_bodystruct);
-PHP_FUNCTION(imap_fetch_overview);
-PHP_FUNCTION(imap_mail_compose);
-PHP_FUNCTION(imap_alerts);
-PHP_FUNCTION(imap_errors);
-PHP_FUNCTION(imap_last_error);
-PHP_FUNCTION(imap_mail);
-PHP_FUNCTION(imap_search);
-PHP_FUNCTION(imap_utf8);
-PHP_FUNCTION(imap_utf7_decode);
-PHP_FUNCTION(imap_utf7_encode);
-PHP_FUNCTION(imap_mime_header_decode);
-#else
-#define imap_module_ptr NULL
-#endif /* HAVE_IMAP */
-
-#endif
-
-
-
-
-
-
-#define phpext_imap_ptr imap_module_ptr
-
-
-
-
-
-
-
-
+++ /dev/null
-dnl $Id$
-dnl config.m4 for extension pcre
-
-dnl By default we'll compile and link against the bundled PCRE library
-dnl if DIR is supplied, we'll use that for linking
-
-PHP_ARG_WITH(pcre-regex,whether to include PCRE support,
-[ --without-pcre-regex Do not include Perl Compatible Regular Expressions
- support. Use --with-pcre-regex=DIR to specify DIR
- where PCRE's include and library files are located,
- if not using bundled library.],yes)
-
-if test "$PHP_PCRE_REGEX" != "no"; then
- PHP_EXTENSION(pcre, $ext_shared)
- if test "$PHP_PCRE_REGEX" = "yes"; then
- PCRE_LIBADD=pcrelib/libpcre.la
- PCRE_SHARED_LIBADD=pcrelib/libpcre.la
- PCRE_SUBDIRS=pcrelib
- PHP_SUBST(PCRE_LIBADD)
- PHP_SUBST(PCRE_SUBDIRS)
- AC_DEFINE(HAVE_BUNDLED_PCRE, 1, [ ])
- PHP_FAST_OUTPUT($ext_builddir/pcrelib/Makefile)
- LIB_BUILD($ext_builddir/pcrelib,$ext_shared,yes)
- else
- test -f $PHP_PCRE_REGEX/pcre.h && PCRE_INCDIR=$PHP_PCRE_REGEX
- test -f $PHP_PCRE_REGEX/include/pcre.h && PCRE_INCDIR=$PHP_PCRE_REGEX/include
-
- if test -z "$PCRE_INCDIR"; then
- AC_MSG_RESULT(Could not find pcre.h in $PHP_PCRE_REGEX)
- fi
-
- changequote({,})
- pcre_major=`grep PCRE_MAJOR $PCRE_INCDIR/pcre.h | sed -e 's/[^0-9]//g'`
- pcre_minor=`grep PCRE_MINOR $PCRE_INCDIR/pcre.h | sed -e 's/[^0-9]//g'`
- changequote([,])
- pcre_minor_length=`echo "$pcre_minor" | wc -c | sed -e 's/[^0-9]//g'`
- if test "$pcre_minor_length" -eq 2 ; then
- pcre_minor="$pcre_minor"0
- fi
- pcre_version=$pcre_major$pcre_minor
- if test "$pcre_version" -lt 208; then
- AC_MSG_ERROR(The PCRE extension requires PCRE library version >= 2.08)
- fi
-
- test -f $PHP_PCRE_REGEX/libpcre.a && PCRE_LIBDIR="$PHP_PCRE_REGEX"
- test -f $PHP_PCRE_REGEX/lib/libpcre.a && PCRE_LIBDIR="$PHP_PCRE_REGEX/lib"
-
- if test -z "$PCRE_LIBDIR" ; then
- AC_MSG_ERROR(Could not find libpcre.a in $PHP_PCRE_REGEX)
- fi
-
- AC_ADD_LIBRARY_WITH_PATH(pcre, $PCRE_LIBDIR, PCRE_SHARED_LIBADD)
-
- AC_ADD_INCLUDE($PCRE_INCDIR)
- AC_DEFINE(HAVE_PCRE, 1, [ ])
- fi
-fi
-PHP_SUBST(PCRE_SHARED_LIBADD)
-
-
-AC_CHECK_FUNC(memmove, [], [AC_DEFINE(USE_BCOPY, 1, [ ])])
+++ /dev/null
-/*
- +----------------------------------------------------------------------+
- | PHP version 4.0 |
- +----------------------------------------------------------------------+
- | Copyright (c) 1997, 1998, 1999, 2000 The PHP Group |
- +----------------------------------------------------------------------+
- | This source file is subject to version 2.02 of the PHP license, |
- | that is bundled with this package in the file LICENSE, and is |
- | available at through the world-wide-web at |
- | http://www.php.net/license/2_02.txt. |
- | If you did not receive a copy of the PHP license and are unable to |
- | obtain it through the world-wide-web, please send a note to |
- | license@php.net so we can mail you a copy immediately. |
- +----------------------------------------------------------------------+
- | Author: Sander Steffann (sander@steffann.nl) |
- +----------------------------------------------------------------------+
- */
-
-#include "php.h"
-
-#if HAVE_UNISTD_H
-#include <unistd.h>
-#endif
-#include <sys/stat.h>
-
-#ifndef MAXSYMLINKS
-#define MAXSYMLINKS 32
-#endif
-
-#ifndef S_ISDIR
-#define S_ISDIR(mode) (((mode)&S_IFMT) == S_IFDIR)
-#endif
-
-char *php_realpath(char *path, char resolved_path[]);
-
-#ifdef PHP_WIN32
-#define IS_SLASH(p) ((p) == '/' || (p) == '\\')
-#else
-#define IS_SLASH(p) ((p) == '/')
-#endif
-
-char *php_realpath(char *path, char resolved_path []) {
- char path_construction[MAXPATHLEN]; /* We build the result in here */
- char *writepos; /* Position to write next char */
-
- char path_copy[MAXPATHLEN]; /* A work-copy of the path */
- char *workpos; /* working position in *path */
-
-#if !defined(PHP_WIN32)
- char buf[MAXPATHLEN]; /* Buffer for readlink */
- int linklength; /* The result from readlink */
-#endif
- int linkcount = 0; /* Count symlinks to avoid loops */
-
- struct stat filestat; /* result from stat */
-
-#ifdef PHP_WIN32
- char *temppos; /* position while counting '.' */
- int dotcount; /* number of '.' */
- int t; /* counter */
-#endif
-
- /* Set the work-position to the beginning of the given path */
- strcpy(path_copy, path);
- workpos = path_copy;
-
-#ifdef PHP_WIN32
- /* Find out where we start - Windows version */
- if (IS_SLASH(*workpos)) {
- /* We start at the root of the current drive */
- /* Get the current directory */
- if (V_GETCWD(path_construction, MAXPATHLEN-1) == NULL) {
- /* Unable to get cwd */
- resolved_path[0] = 0;
- return NULL;
- }
- /* We only need the first three chars (for example "C:\") */
- path_construction[3] = 0;
- workpos++;
- } else if (workpos[1] == ':') {
- /* A drive-letter is specified, copy it */
- strncpy(path_construction, path, 2);
- strcat(path_construction, "\\");
- workpos++;
- workpos++;
- } else {
- /* Use the current directory */
- if (V_GETCWD(path_construction, MAXPATHLEN-1) == NULL) {
- /* Unable to get cwd */
- resolved_path[0] = 0;
- return NULL;
- }
- strcat(path_construction, "\\");
- }
-#else
- /* Find out where we start - Unix version */
- if (*workpos == '/') {
- /* We start at the root */
- strcpy(path_construction, "/");
- workpos++;
- } else {
- /* Use the current directory */
- if (V_GETCWD(path_construction, MAXPATHLEN-1) == NULL) {
- /* Unable to get cwd */
- resolved_path[0] = 0;
- return NULL;
- }
- strcat(path_construction, "/");
- }
-#endif
-
- /* Set the next-char-position */
- writepos = &path_construction[strlen(path_construction)];
-
- /* Go to the end, then stop */
- while(*workpos != 0) {
- /* Strip (back)slashes */
- while(IS_SLASH(*workpos)) workpos++;
-
-#ifdef PHP_WIN32
- /* reset dotcount */
- dotcount = 0;
-
- /* Look for .. */
- if ((workpos[0] == '.') && (workpos[1] != 0)) {
- /* Windows accepts \...\ as \..\..\, \....\ as \..\..\..\, etc */
- /* At least Win98 does */
-
- temppos = workpos;
- while(*temppos++ == '.') {
- dotcount++;
- if (!IS_SLASH(*temppos) && (*temppos != 0) && (*temppos != '.')) {
- /* This is not a /../ component, but a filename that starts with '.' */
- dotcount = 0;
- }
- }
-
- /* Go back dotcount-1 times */
- for (t=0 ; t<(dotcount-1) ; t++) {
- workpos++; /* move to next '.' */
-
- /* Can we still go back? */
- if ((writepos-3) <= path_construction) return NULL;
-
- /* Go back */
- writepos--; /* move to '\' */
- writepos--;
- while(!IS_SLASH(*writepos)) writepos--; /* skip until previous '\\' */
- }
- workpos++;
- }
-
- /* No special case */
- if (dotcount == 0) {
- /* Append */
- while(!IS_SLASH(*workpos) && (*workpos != 0)) {
- *writepos++ = *workpos++;
- }
- }
-
- /* Just one '.', go to next element */
- if (dotcount == 1) {
- while(!IS_SLASH(*workpos) && (*workpos != 0)) {
- *workpos++;
- }
-
- /* Avoid double \ in the result */
- writepos--;
- }
-
- /* If it was a directory, append a slash */
- if (IS_SLASH(*workpos)) {
- *writepos++ = *workpos++;
- }
- *writepos = 0;
-#else /* defined(PHP_WIN32) */
- /* Look for .. */
- if ((workpos[0] == '.') && (workpos[1] != 0)) {
- if ((workpos[1] == '.') && ((workpos[2] == '/') || (workpos[2] == 0))) {
- /* One directory back */
- /* Set pointers to right position */
- workpos++; /* move to second '.' */
- workpos++; /* move to '/' */
-
- /* Only apply .. if not in root */
- if ((writepos-1) > path_construction) {
- writepos--; /* move to '/' */
- while(*--writepos != '/') ; /* skip until previous '/' */
- }
- } else {
- if (workpos[1] == '/') {
- /* Found a /./ skip it */
- workpos++; /* move to '/' */
-
- /* Avoid double / in the result */
- writepos--;
- } else {
- /* No special case, the name just started with a . */
- /* Append */
- while((*workpos != '/') && (*workpos != 0)) {
- *writepos++ = *workpos++;
- }
- }
- }
- } else {
- /* No special case */
- /* Append */
- while((*workpos != '/') && (*workpos != 0)) {
- *writepos++ = *workpos++;
- }
- }
-
-#if HAVE_SYMLINK
- /* We are going to use path_construction, so close it */
- *writepos = 0;
-
- /* Check the current location to see if it is a symlink */
- if((linklength = readlink(path_construction, buf, MAXPATHLEN)) != -1) {
- /* Check linkcount */
- if (linkcount > MAXSYMLINKS) return NULL;
-
- /* Count this symlink */
- linkcount++;
-
- /* Set end of buf */
- buf[linklength] = 0;
-
- /* Check for overflow */
- if ((strlen(workpos) + strlen(buf) + 1) >= MAXPATHLEN) return NULL;
-
- /* Remove the symlink-component wrom path_construction */
- writepos--; /* move to '/' */
- while(*--writepos != '/') ; /* skip until previous '/' */
- *++writepos = 0; /* end of string after '/' */
-
- /* If the symlink starts with a '/', empty path_construction */
- if (*buf == '/') {
- *path_construction = 0;
- writepos = path_construction;
- }
-
- /* Insert symlink into path_copy */
- strcat(buf, workpos);
- strcpy(path_copy, buf);
- workpos = path_copy;
- }
-#endif /* HAVE_SYMLINK */
-
- /* If it was a directory, append a slash */
- if (*workpos == '/') {
- *writepos++ = *workpos++;
- }
- *writepos = 0;
-#endif /* defined(PHP_WIN32) */
- }
-
- /* Check if the resolved path is a directory */
- if (V_STAT(path_construction, &filestat) != 0) {
- if (errno != ENOENT) return NULL;
- } else {
- if (S_ISDIR(filestat.st_mode)) {
- /* It's a directory, append a / if needed */
- if (*(writepos-1) != '/') {
- /* Check for overflow */
- if ((strlen(workpos) + 2) >= MAXPATHLEN) {
- return NULL;
- }
- *writepos++ = '/';
- *writepos = 0;
- }
- }
- }
-
- strcpy(resolved_path, path_construction);
- return resolved_path;
-}
-
-/*
- * Local variables:
- * tab-width: 4
- * c-basic-offset: 4
- * End:
- */
/* automatically generated by configure */
/* edit configure.in to change version number */
-#define PHP_VERSION "4.0.3-dev"
+#define PHP_VERSION "4.0.3RC1"
--- /dev/null
+#if 0
+/*
+ +----------------------------------------------------------------------+
+ | PHP version 4.0 |
+ +----------------------------------------------------------------------+
+ | Copyright (c) 1997, 1998, 1999, 2000 The PHP Group |
+ +----------------------------------------------------------------------+
+ | This source file is subject to version 2.02 of the PHP license, |
+ | that is bundled with this package in the file LICENSE, and is |
+ | available at through the world-wide-web at |
+ | http://www.php.net/license/2_02.txt. |
+ | If you did not receive a copy of the PHP license and are unable to |
+ | obtain it through the world-wide-web, please send a note to |
+ | license@php.net so we can mail you a copy immediately. |
+ +----------------------------------------------------------------------+
+ | Authors: Andi Gutmans <andi@zend.com> |
+ | Sascha Schumann <sascha@schumann.cx> |
+ +----------------------------------------------------------------------+
+*/
+
+/* $Id$ */
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <string.h>
+#include <stdio.h>
+#include <limits.h>
+#include <errno.h>
+#include <stdlib.h>
+#include <fcntl.h>
+
+#ifdef ZEND_WIN32
+/* mode_t isn't defined on Windows */
+typedef int mode_t;
+#include <sys/utime.h>
+#endif
+
+#include "php_virtual_cwd.h"
+#include "php_reentrancy.h" /* for php_strtok_r */
+
+#define VIRTUAL_CWD_DEBUG 0
+
+#ifdef ZTS
+#include "TSRM.h"
+#endif
+
+/* Only need mutex for popen() in Windows because it doesn't chdir() on UNIX */
+#if defined(ZEND_WIN32) && defined(ZTS)
+MUTEX_T cwd_mutex;
+#endif
+
+#ifdef ZTS
+static ts_rsrc_id cwd_globals_id;
+#else
+static virtual_cwd_globals cwd_globals;
+#endif
+
+cwd_state main_cwd_state; /* True global */
+
+#ifndef ZEND_WIN32
+#include <unistd.h>
+#else
+#include <direct.h>
+#endif
+
+#ifndef S_ISDIR
+#define S_ISDIR(mode) ((mode) & _S_IFDIR)
+#endif
+
+#ifndef S_ISREG
+#define S_ISREG(mode) ((mode) & _S_IFREG)
+#endif
+
+#ifdef ZEND_WIN32
+#define php_strtok_r(a,b,c) strtok((a),(b))
+#define DEFAULT_SLASH '\\'
+#define TOKENIZER_STRING "/\\"
+
+#define COPY_WHEN_ABSOLUTE 2
+
+static int php_check_dots(const char *element, int n)
+{
+ while (n-- > 0) if (element[n] != '.') break;
+
+ return (n != -1);
+}
+
+#define IS_DIRECTORY_UP(element, len) \
+ (len >= 2 && !php_check_dots(element, len))
+
+#define IS_DIRECTORY_CURRENT(element, len) \
+ (len == 1 && ptr[0] == '.')
+
+
+#else
+#define DEFAULT_SLASH '/'
+#define TOKENIZER_STRING "/"
+#endif
+
+
+/* default macros */
+
+#ifndef IS_DIRECTORY_UP
+#define IS_DIRECTORY_UP(element, len) \
+ (len == 2 && memcmp(element, "..", 2) == 0)
+#endif
+
+#ifndef IS_DIRECTORY_CURRENT
+#define IS_DIRECTORY_CURRENT(element, len) \
+ (len == 1 && ptr[0] == '.')
+#endif
+
+#ifndef COPY_WHEN_ABSOLUTE
+#define COPY_WHEN_ABSOLUTE 0
+#endif
+
+/* define this to check semantics */
+#define IS_DIR_OK(s) (1)
+
+#ifndef IS_DIR_OK
+#define IS_DIR_OK(state) (php_is_dir_ok(state) == 0)
+#endif
+
+
+#define CWD_STATE_COPY(d, s) \
+ (d)->cwd_length = (s)->cwd_length; \
+ (d)->cwd = (char *) malloc((s)->cwd_length+1); \
+ memcpy((d)->cwd, (s)->cwd, (s)->cwd_length+1);
+
+#define CWD_STATE_FREE(s) \
+ free((s)->cwd);
+
+static int php_is_dir_ok(const cwd_state *state)
+{
+ struct stat buf;
+
+ if (stat(state->cwd, &buf) == 0 && S_ISDIR(buf.st_mode))
+ return (0);
+
+ return (1);
+}
+
+static int php_is_file_ok(const cwd_state *state)
+{
+ struct stat buf;
+
+ if (stat(state->cwd, &buf) == 0 && S_ISREG(buf.st_mode))
+ return (0);
+
+ return (1);
+}
+
+static void cwd_globals_ctor(virtual_cwd_globals *cwd_globals)
+{
+ CWD_STATE_COPY(&cwd_globals->cwd, &main_cwd_state);
+}
+
+static void cwd_globals_dtor(virtual_cwd_globals *cwd_globals)
+{
+ CWD_STATE_FREE(&cwd_globals->cwd);
+}
+
+CWD_API void virtual_cwd_startup(void)
+{
+ char cwd[MAXPATHLEN];
+ char *result;
+
+ result = getcwd(cwd, sizeof(cwd));
+ if (!result) {
+ cwd[0] = '\0';
+ }
+ main_cwd_state.cwd = strdup(cwd);
+ main_cwd_state.cwd_length = strlen(cwd);
+
+#ifdef ZTS
+ cwd_globals_id = ts_allocate_id(sizeof(virtual_cwd_globals), (ts_allocate_ctor) cwd_globals_ctor, (ts_allocate_dtor) cwd_globals_dtor);
+#else
+ cwd_globals_ctor(&cwd_globals);
+#endif
+
+#if defined(ZEND_WIN32) && defined(ZTS)
+ cwd_mutex = tsrm_mutex_alloc();
+#endif
+}
+
+CWD_API void virtual_cwd_shutdown(void)
+{
+#ifndef ZTS
+ cwd_globals_dtor(&cwd_globals);
+#endif
+#if defined(ZEND_WIN32) && defined(ZTS)
+ tsrm_mutex_free(cwd_mutex);
+#endif
+
+ free(main_cwd_state.cwd); /* Don't use CWD_STATE_FREE because the non global states will probably use emalloc()/efree() */
+}
+
+CWD_API char *virtual_getcwd_ex(int *length)
+{
+ cwd_state *state;
+ CWDLS_FETCH();
+
+ state = &CWDG(cwd);
+
+ if (state->cwd_length == 0) {
+ char *retval;
+
+ *length = 1;
+ retval = (char *) malloc(2);
+ retval[0] = DEFAULT_SLASH;
+ retval[1] = '\0';
+ return retval;
+ }
+
+#ifdef ZEND_WIN32
+ /* If we have something like C: */
+ if (state->cwd_length == 2 && state->cwd[state->cwd_length-1] == ':') {
+ char *retval;
+
+ *length = state->cwd_length+1;
+ retval = (char *) malloc(*length+1);
+ memcpy(retval, state->cwd, *length);
+ retval[*length-1] = DEFAULT_SLASH;
+ retval[*length] = '\0';
+ return retval;
+ }
+#endif
+ *length = state->cwd_length;
+ return strdup(state->cwd);
+}
+
+
+/* Same semantics as UNIX getcwd() */
+CWD_API char *virtual_getcwd(char *buf, size_t size)
+{
+ size_t length;
+ char *cwd;
+
+ cwd = virtual_getcwd_ex(&length);
+
+ if (buf == NULL) {
+ return cwd;
+ }
+ if (length > size-1) {
+ free(cwd);
+ errno = ERANGE; /* Is this OK? */
+ return NULL;
+ }
+ memcpy(buf, cwd, length+1);
+ free(cwd);
+ return buf;
+}
+
+/* Resolve path relatively to state and put the real path into state */
+/* returns 0 for ok, 1 for error */
+CWD_API int virtual_file_ex(cwd_state *state, const char *path, verify_path_func verify_path)
+{
+ int path_length = strlen(path);
+ char *ptr, *path_copy;
+ char *tok = NULL;
+ int ptr_length;
+ cwd_state *old_state;
+ int ret = 0;
+ int copy_amount = -1;
+ char *free_path;
+ zend_bool is_absolute = 0;
+#ifndef ZEND_WIN32
+ char resolved_path[MAXPATHLEN];
+#endif
+
+ if (path_length == 0)
+ return (0);
+
+#ifndef ZEND_WIN32
+ if (IS_ABSOLUTE_PATH(path, path_length)) {
+ if (realpath(path, resolved_path)) {
+ path = resolved_path;
+ path_length = strlen(path);
+ }
+ } else { /* Concat current directory with relative path and then run realpath() on it */
+ char *tmp;
+ char *ptr;
+
+ ptr = tmp = (char *) malloc(state->cwd_length+path_length+sizeof("/"));
+ if (!tmp) {
+ return 1;
+ }
+ memcpy(ptr, state->cwd, state->cwd_length);
+ ptr += state->cwd_length;
+ *ptr++ = DEFAULT_SLASH;
+ memcpy(ptr, path, path_length);
+ ptr += path_length;
+ *ptr = '\0';
+ if (realpath(tmp, resolved_path)) {
+ path = resolved_path;
+ path_length = strlen(path);
+ }
+ free(tmp);
+ }
+#endif
+ free_path = path_copy = estrndup(path, path_length);
+
+ old_state = (cwd_state *) malloc(sizeof(cwd_state));
+ CWD_STATE_COPY(old_state, state);
+#if VIRTUAL_CWD_DEBUG
+ fprintf(stderr,"cwd = %s path = %s\n", state->cwd, path);
+#endif
+ if (IS_ABSOLUTE_PATH(path_copy, path_length)) {
+ copy_amount = COPY_WHEN_ABSOLUTE;
+ is_absolute = 1;
+#ifdef ZEND_WIN32
+ } else if(IS_SLASH(path_copy[0])) {
+ copy_amount = 2;
+#endif
+ }
+
+ if (copy_amount != -1) {
+ state->cwd = (char *) realloc(state->cwd, copy_amount + 1);
+ if (copy_amount) {
+ if (is_absolute) {
+ memcpy(state->cwd, path_copy, copy_amount);
+ path_copy += copy_amount;
+ } else {
+ memcpy(state->cwd, old_state->cwd, copy_amount);
+ }
+ }
+ state->cwd[copy_amount] = '\0';
+ state->cwd_length = copy_amount;
+ }
+
+
+ ptr = php_strtok_r(path_copy, TOKENIZER_STRING, &tok);
+ while (ptr) {
+ ptr_length = strlen(ptr);
+
+ if (IS_DIRECTORY_UP(ptr, ptr_length)) {
+ char save;
+
+ save = DEFAULT_SLASH;
+
+#define PREVIOUS state->cwd[state->cwd_length - 1]
+
+ while (IS_ABSOLUTE_PATH(state->cwd, state->cwd_length) &&
+ !IS_SLASH(PREVIOUS)) {
+ save = PREVIOUS;
+ PREVIOUS = '\0';
+ state->cwd_length--;
+ }
+
+ if (!IS_ABSOLUTE_PATH(state->cwd, state->cwd_length)) {
+ state->cwd[state->cwd_length++] = save;
+ state->cwd[state->cwd_length] = '\0';
+ } else {
+ PREVIOUS = '\0';
+ state->cwd_length--;
+ }
+ } else if (!IS_DIRECTORY_CURRENT(ptr, ptr_length)) {
+ state->cwd = (char *) realloc(state->cwd, state->cwd_length+ptr_length+1+1);
+ state->cwd[state->cwd_length] = DEFAULT_SLASH;
+ memcpy(&state->cwd[state->cwd_length+1], ptr, ptr_length+1);
+ state->cwd_length += (ptr_length+1);
+ }
+ ptr = php_strtok_r(NULL, TOKENIZER_STRING, &tok);
+ }
+
+ if (state->cwd_length == COPY_WHEN_ABSOLUTE) {
+ state->cwd = (char *) realloc(state->cwd, state->cwd_length+1+1);
+ state->cwd[state->cwd_length] = DEFAULT_SLASH;
+ state->cwd[state->cwd_length+1] = '\0';
+ state->cwd_length++;
+ }
+
+ if (verify_path && verify_path(state)) {
+ CWD_STATE_FREE(state);
+
+ *state = *old_state;
+
+ ret = 1;
+ } else {
+ CWD_STATE_FREE(old_state);
+ ret = 0;
+ }
+
+ free(old_state);
+
+ efree(free_path);
+#if VIRTUAL_CWD_DEBUG
+ fprintf (stderr, "virtual_file_ex() = %s\n",state->cwd);
+#endif
+ return (ret);
+}
+
+CWD_API int virtual_chdir(const char *path)
+{
+ CWDLS_FETCH();
+
+ return virtual_file_ex(&CWDG(cwd), path, php_is_dir_ok)?-1:0;
+}
+
+CWD_API int virtual_chdir_file(const char *path, int (*p_chdir)(const char *path))
+{
+ int length = strlen(path);
+ char *temp;
+ int retval;
+
+ if (length == 0) {
+ return 1; /* Can't cd to empty string */
+ }
+ while(--length >= 0 && !IS_SLASH(path[length])) {
+ }
+
+ if (length == -1) {
+ return virtual_chdir(path);
+ }
+
+ if (length == COPY_WHEN_ABSOLUTE && IS_ABSOLUTE_PATH(path, length+1)) { /* Also use trailing slash if this is absolute */
+ length++;
+ }
+ temp = (char *) do_alloca(length+1);
+ memcpy(temp, path, length);
+ temp[length] = 0;
+#if VIRTUAL_CWD_DEBUG
+ fprintf (stderr, "Changing directory to %s\n", temp);
+#endif
+ retval = p_chdir(temp);
+ free_alloca(temp);
+ return retval;
+}
+
+CWD_API char *virtual_realpath(const char *path, char *real_path)
+{
+ cwd_state new_state;
+ int retval;
+ CWDLS_FETCH();
+
+ CWD_STATE_COPY(&new_state, &CWDG(cwd));
+ retval = virtual_file_ex(&new_state, path, NULL);
+
+ if(retval) {
+ int len = new_state.cwd_length>MAXPATHLEN-1?MAXPATHLEN-1:new_state.cwd_length;
+ memcpy(real_path, new_state.cwd, len);
+ real_path[len] = '\0';
+ return real_path;
+ }
+
+ return NULL;
+}
+
+CWD_API int virtual_filepath(const char *path, char **filepath)
+{
+ cwd_state new_state;
+ int retval;
+ CWDLS_FETCH();
+
+ CWD_STATE_COPY(&new_state, &CWDG(cwd));
+ retval = virtual_file_ex(&new_state, path, php_is_file_ok);
+
+ *filepath = new_state.cwd;
+
+ return retval;
+}
+
+CWD_API FILE *virtual_fopen(const char *path, const char *mode)
+{
+ cwd_state new_state;
+ FILE *f;
+ CWDLS_FETCH();
+
+ if (path[0] == '\0') { /* Fail to open empty path */
+ return NULL;
+ }
+
+ CWD_STATE_COPY(&new_state, &CWDG(cwd));
+ virtual_file_ex(&new_state, path, NULL);
+
+ f = fopen(new_state.cwd, mode);
+
+ CWD_STATE_FREE(&new_state);
+ return f;
+}
+
+#if HAVE_UTIME
+CWD_API int virtual_utime(const char *filename, struct utimbuf *buf)
+{
+ cwd_state new_state;
+ int ret;
+ CWDLS_FETCH();
+
+ CWD_STATE_COPY(&new_state, &CWDG(cwd));
+ virtual_file_ex(&new_state, filename, NULL);
+
+ ret = utime(new_state.cwd, buf);
+
+ CWD_STATE_FREE(&new_state);
+ return ret;
+}
+#endif
+
+CWD_API int virtual_chmod(const char *filename, mode_t mode)
+{
+ cwd_state new_state;
+ int ret;
+ CWDLS_FETCH();
+
+ CWD_STATE_COPY(&new_state, &CWDG(cwd));
+ virtual_file_ex(&new_state, filename, NULL);
+
+ ret = chmod(new_state.cwd, mode);
+
+ CWD_STATE_FREE(&new_state);
+ return ret;
+}
+
+#ifndef PHP_WIN32
+CWD_API int virtual_chown(const char *filename, uid_t owner, gid_t group)
+{
+ cwd_state new_state;
+ int ret;
+ CWDLS_FETCH();
+
+ CWD_STATE_COPY(&new_state, &CWDG(cwd));
+ virtual_file_ex(&new_state, filename, NULL);
+
+ ret = chown(new_state.cwd, owner, group);
+
+ CWD_STATE_FREE(&new_state);
+ return ret;
+}
+#endif
+
+CWD_API int virtual_open(const char *path, int flags, ...)
+{
+ cwd_state new_state;
+ int f;
+ CWDLS_FETCH();
+
+ CWD_STATE_COPY(&new_state, &CWDG(cwd));
+ virtual_file_ex(&new_state, path, NULL);
+
+ if (flags & O_CREAT) {
+ mode_t mode;
+ va_list arg;
+
+ va_start(arg, flags);
+ mode = va_arg(arg, mode_t);
+ va_end(arg);
+
+ f = open(new_state.cwd, flags, mode);
+ } else {
+ f = open(new_state.cwd, flags);
+ }
+ CWD_STATE_FREE(&new_state);
+ return f;
+}
+
+CWD_API int virtual_creat(const char *path, mode_t mode)
+{
+ cwd_state new_state;
+ int f;
+ CWDLS_FETCH();
+
+ CWD_STATE_COPY(&new_state, &CWDG(cwd));
+ virtual_file_ex(&new_state, path, NULL);
+
+ f = creat(new_state.cwd, mode);
+
+ CWD_STATE_FREE(&new_state);
+ return f;
+}
+
+
+CWD_API int virtual_stat(const char *path, struct stat *buf)
+{
+ cwd_state new_state;
+ int retval;
+ CWDLS_FETCH();
+
+ CWD_STATE_COPY(&new_state, &CWDG(cwd));
+ virtual_file_ex(&new_state, path, NULL);
+
+ retval = stat(new_state.cwd, buf);
+
+ CWD_STATE_FREE(&new_state);
+ return retval;
+}
+
+#ifndef ZEND_WIN32
+
+CWD_API int virtual_lstat(const char *path, struct stat *buf)
+{
+ cwd_state new_state;
+ int retval;
+ CWDLS_FETCH();
+
+ CWD_STATE_COPY(&new_state, &CWDG(cwd));
+ virtual_file_ex(&new_state, path, NULL);
+
+ retval = lstat(new_state.cwd, buf);
+
+ CWD_STATE_FREE(&new_state);
+ return retval;
+}
+
+#endif
+
+CWD_API int virtual_unlink(const char *path)
+{
+ cwd_state new_state;
+ int retval;
+ CWDLS_FETCH();
+
+ CWD_STATE_COPY(&new_state, &CWDG(cwd));
+ virtual_file_ex(&new_state, path, NULL);
+
+ retval = unlink(new_state.cwd);
+
+ CWD_STATE_FREE(&new_state);
+ return retval;
+}
+
+CWD_API int virtual_mkdir(const char *pathname, mode_t mode)
+{
+ cwd_state new_state;
+ int retval;
+ CWDLS_FETCH();
+
+ CWD_STATE_COPY(&new_state, &CWDG(cwd));
+ virtual_file_ex(&new_state, pathname, NULL);
+
+ retval = mkdir(new_state.cwd, mode);
+
+ CWD_STATE_FREE(&new_state);
+ return retval;
+}
+
+CWD_API int virtual_rmdir(const char *pathname)
+{
+ cwd_state new_state;
+ int retval;
+ CWDLS_FETCH();
+
+ CWD_STATE_COPY(&new_state, &CWDG(cwd));
+ virtual_file_ex(&new_state, pathname, NULL);
+
+ retval = rmdir(new_state.cwd);
+
+ CWD_STATE_FREE(&new_state);
+ return retval;
+}
+
+CWD_API DIR *virtual_opendir(const char *pathname)
+{
+ cwd_state new_state;
+ DIR *retval;
+ CWDLS_FETCH();
+
+ CWD_STATE_COPY(&new_state, &CWDG(cwd));
+ virtual_file_ex(&new_state, pathname, NULL);
+
+ retval = opendir(new_state.cwd);
+
+ CWD_STATE_FREE(&new_state);
+ return retval;
+}
+
+#ifndef ZEND_WIN32
+
+CWD_API FILE *virtual_popen(const char *command, const char *type)
+{
+ int command_length;
+ char *command_line;
+ char *ptr;
+ FILE *retval;
+ CWDLS_FETCH();
+
+ command_length = strlen(command);
+
+ ptr = command_line = (char *) malloc(command_length + sizeof("cd ; ") + CWDG(cwd).cwd_length+1);
+ if (!command_line) {
+ return NULL;
+ }
+ memcpy(ptr, "cd ", sizeof("cd ")-1);
+ ptr += sizeof("cd ")-1;
+
+ if (CWDG(cwd).cwd_length == 0) {
+ *ptr++ = DEFAULT_SLASH;
+ } else {
+ memcpy(ptr, CWDG(cwd).cwd, CWDG(cwd).cwd_length);
+ ptr += CWDG(cwd).cwd_length;
+ }
+
+ *ptr++ = ' ';
+ *ptr++ = ';';
+ *ptr++ = ' ';
+
+ memcpy(ptr, command, command_length+1);
+ retval = popen(command_line, type);
+ free(command_line);
+ return retval;
+}
+
+#else
+
+/* On Windows the trick of prepending "cd cwd; " doesn't work so we need to perform
+ a real chdir() and mutex it
+ */
+CWD_API FILE *virtual_popen(const char *command, const char *type)
+{
+ char prev_cwd[MAXPATHLEN];
+ char *getcwd_result;
+ FILE *retval;
+ CWDLS_FETCH();
+
+ getcwd_result = getcwd(prev_cwd, MAXPATHLEN);
+ if (!getcwd_result) {
+ return NULL;
+ }
+
+#ifdef ZTS
+ tsrm_mutex_lock(cwd_mutex);
+#endif
+
+ chdir(CWDG(cwd).cwd);
+ retval = popen(command, type);
+ chdir(prev_cwd);
+
+#ifdef ZTS
+ tsrm_mutex_unlock(cwd_mutex);
+#endif
+
+ return retval;
+}
+
+#endif
+
+#endif
+
+/*
+ * Local variables:
+ * tab-width: 4
+ * c-basic-offset: 4
+ * End:
+ */
--- /dev/null
+#if 0
+
+/*
+ +----------------------------------------------------------------------+
+ | PHP version 4.0 |
+ +----------------------------------------------------------------------+
+ | Copyright (c) 1997, 1998, 1999, 2000 The PHP Group |
+ +----------------------------------------------------------------------+
+ | This source file is subject to version 2.02 of the PHP license, |
+ | that is bundled with this package in the file LICENSE, and is |
+ | available at through the world-wide-web at |
+ | http://www.php.net/license/2_02.txt. |
+ | If you did not receive a copy of the PHP license and are unable to |
+ | obtain it through the world-wide-web, please send a note to |
+ | license@php.net so we can mail you a copy immediately. |
+ +----------------------------------------------------------------------+
+ | Authors: Andi Gutmans <andi@zend.com> |
+ | Sascha Schumann <sascha@schumann.cx> |
+ +----------------------------------------------------------------------+
+*/
+
+/* $Id$ */
+
+#ifndef VIRTUAL_CWD_H
+#define VIRTUAL_CWD_H
+
+#include "zend.h"
+#include "zend_API.h"
+
+#include <sys/types.h>
+#include <sys/stat.h>
+
+#ifdef HAVE_UTIME_H
+#include <utime.h>
+#endif
+
+#ifndef ZEND_WIN32
+#include <unistd.h>
+#endif
+
+#include <ctype.h>
+
+#ifdef ZEND_WIN32
+#include "win32/readdir.h"
+
+#define IS_SLASH(c) ((c) == '/' || (c) == '\\')
+
+#define IS_ABSOLUTE_PATH(path, len) \
+ (len >= 2 && isalpha(path[0]) && path[1] == ':')
+
+#else
+#ifdef HAVE_DIRENT_H
+#include <dirent.h>
+#endif
+
+#define IS_SLASH(c) ((c) == '/')
+
+#endif
+
+#ifndef IS_ABSOLUTE_PATH
+#define IS_ABSOLUTE_PATH(path, len) \
+ (IS_SLASH(path[0]))
+#endif
+
+#if HAVE_UTIME
+# ifdef PHP_WIN32
+# include <sys/utime.h>
+# endif
+#endif
+
+#ifdef PHP_EXPORTS
+#define CWD_EXPORTS
+#endif
+
+#ifdef ZEND_WIN32
+# ifdef CWD_EXPORTS
+# define CWD_API __declspec(dllexport)
+# else
+# define CWD_API __declspec(dllimport)
+# endif
+#else
+#define CWD_API
+#endif
+
+typedef struct _cwd_state {
+ char *cwd;
+ int cwd_length;
+} cwd_state;
+
+typedef int (*verify_path_func)(const cwd_state *);
+
+CWD_API void virtual_cwd_startup(void);
+CWD_API void virtual_cwd_shutdown(void);
+CWD_API char *virtual_getcwd_ex(int *length);
+CWD_API char *virtual_getcwd(char *buf, size_t size);
+CWD_API int virtual_chdir(const char *path);
+CWD_API int virtual_chdir_file(const char *path, int (*p_chdir)(const char *path));
+/* CWD_API void virtual_real_chdir_file(const char *path); */
+CWD_API int virtual_filepath(const char *path, char **filepath);
+CWD_API char *virtual_realpath(const char *path, char *real_path);
+CWD_API FILE *virtual_fopen(const char *path, const char *mode);
+CWD_API int virtual_open(const char *path, int flags, ...);
+CWD_API int virtual_creat(const char *path, mode_t mode);
+CWD_API int virtual_stat(const char *path, struct stat *buf);
+#ifndef ZEND_WIN32
+CWD_API int virtual_lstat(const char *path, struct stat *buf);
+#endif
+CWD_API int virtual_unlink(const char *path);
+CWD_API int virtual_mkdir(const char *pathname, mode_t mode);
+CWD_API int virtual_rmdir(const char *pathname);
+CWD_API DIR *virtual_opendir(const char *pathname);
+CWD_API FILE *virtual_popen(const char *command, const char *type);
+#if HAVE_UTIME
+CWD_API int virtual_utime(const char *filename, struct utimbuf *buf);
+#endif
+CWD_API int virtual_chmod(const char *filename, mode_t mode);
+#ifndef PHP_WIN32
+CWD_API int virtual_chown(const char *filename, uid_t owner, gid_t group);
+#endif
+
+CWD_API int virtual_file_ex(cwd_state *state, const char *path, verify_path_func verify_path);
+
+typedef struct _virtual_cwd_globals {
+ cwd_state cwd;
+} virtual_cwd_globals;
+
+#ifdef ZTS
+# define CWDLS_D virtual_cwd_globals *cwd_globals
+# define CWDLS_DC , CWDLS_D
+# define CWDLS_C cwd_globals
+# define CWDLS_CC , CWDLS_C
+# define CWDG(v) (cwd_globals->v)
+# define CWDLS_FETCH() virtual_cwd_globals *cwd_globals = ts_resource(cwd_globals_id)
+#else
+# define CWDLS_D void
+# define CWDLS_DC
+# define CWDLS_C
+# define CWDLS_CC
+# define CWDG(v) (cwd_globals.v)
+# define CWDLS_FETCH()
+#endif
+
+#endif /* VIRTUAL_CWD_H */
+
+#endif
--- /dev/null
+--TEST--
+PEAR_Error in callback mode
+--SKIPIF--
+--FILE--
+<?php
+
+require_once "PEAR.php";
+
+function error_function($obj) {
+ print "this is error_function reporting: ";
+ print $obj->toString();
+ print "\n";
+}
+class myclass {
+ function error_method($obj) {
+ print "this is myclass::error_method reporting: ";
+ print $obj->toString();
+ print "\n";
+ }
+}
+$obj = new myclass;
+new PEAR_Error("errortest1", 0, PEAR_ERROR_CALLBACK, "error_function");
+new PEAR_Error("errortest2", 0, PEAR_ERROR_CALLBACK,
+ array(&$obj, "error_method"));
+
+
+?>
+--GET--
+--POST--
+--EXPECT--
+this is error_function reporting: [pear_error: message="errortest1" code=0 mode=callback level=notice prefix="" prepend="" append=""]
+this is myclass::error_method reporting: [pear_error: message="errortest2" code=0 mode=callback level=notice prefix="" prepend="" append=""]
+++ /dev/null
-#include "php.h"
-
-#ifndef HAVE_STRTOK_R
-
-/*
- * Copyright (c) 1998 Softweyr LLC. All rights reserved.
- *
- * strtok_r, from Berkeley strtok
- * Oct 13, 1998 by Wes Peters <wes@softweyr.com>
- *
- * Copyright (c) 1988, 1993
- * The Regents of the University of California. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- *
- * 1. Redistributions of source code must retain the above copyright
- * notices, this list of conditions and the following disclaimer.
- *
- * 2. Redistributions in binary form must reproduce the above copyright
- * notices, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- *
- * 3. All advertising materials mentioning features or use of this software
- * must display the following acknowledgement:
- *
- * This product includes software developed by Softweyr LLC, the
- * University of California, Berkeley, and its contributors.
- *
- * 4. Neither the name of the University nor the names of its contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY SOFTWEYR LLC, THE REGENTS AND CONTRIBUTORS
- * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
- * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SOFTWEYR LLC, THE
- * REGENTS, OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
- * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#include <stddef.h>
-#include <string.h>
-
-char *
-strtok_r(char *s, const char *delim, char **last)
-{
- char *spanp;
- int c, sc;
- char *tok;
-
- if (s == NULL && (s = *last) == NULL)
- {
- return NULL;
- }
-
- /*
- * Skip (span) leading delimiters (s += strspn(s, delim), sort of).
- */
-cont:
- c = *s++;
- for (spanp = (char *)delim; (sc = *spanp++) != 0; )
- {
- if (c == sc)
- {
- goto cont;
- }
- }
-
- if (c == 0) /* no non-delimiter characters */
- {
- *last = NULL;
- return NULL;
- }
- tok = s - 1;
-
- /*
- * Scan token (scan for delimiters: s += strcspn(s, delim), sort of).
- * Note that delim must have one NUL; we stop if we see that, too.
- */
- for (;;)
- {
- c = *s++;
- spanp = (char *)delim;
- do
- {
- if ((sc = *spanp++) == c)
- {
- if (c == 0)
- {
- s = NULL;
- }
- else
- {
- char *w = s - 1;
- *w = '\0';
- }
- *last = s;
- return tok;
- }
- }
- while (sc != 0);
- }
- /* NOTREACHED */
-}
-
-#endif
projects / php / commitdiff