mirror of
https://github.com/bdnugget/php-src.git
synced 2026-11-14 04:30:50 +00:00
Compare commits
1
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
 SVN Migration
|
4b95916fe6 |
No files matched your search
@@ -1,233 +0,0 @@
|
||||
PHP Coding Standards
|
||||
====================
|
||||
|
||||
|
||||
This file lists several standards that any programmer, adding or changing
|
||||
code in PHP, should follow. Since this file was added at a very late
|
||||
stage of the development of PHP v3.0, the code base does not (yet) fully
|
||||
follow it, but it's going in that general direction. Since we are now
|
||||
well into the version 4 releases, many sections have been recoded to use
|
||||
these rules.
|
||||
|
||||
|
||||
Code Implementation
|
||||
-------------------
|
||||
|
||||
[1] Functions that are given pointers to resources should not free them
|
||||
|
||||
For instance, function int mail(char *to, char *from) should NOT free
|
||||
to and/or from.
|
||||
Exceptions:
|
||||
|
||||
- The function's designated behavior is freeing that resource. E.g. efree()
|
||||
- The function is given a boolean argument, that controls whether or not
|
||||
the function may free its arguments (if true - the function must free its
|
||||
arguments, if false - it must not)
|
||||
- Low-level parser routines, that are tightly integrated with the token
|
||||
cache and the bison code for minimum memory copying overhead.
|
||||
|
||||
[2] Functions that are tightly integrated with other functions within the
|
||||
same module, and rely on each other non-trivial behavior, should be
|
||||
documented as such and declared 'static'. They should be avoided if
|
||||
possible.
|
||||
|
||||
[3] Use definitions and macros whenever possible, so that constants have
|
||||
meaningful names and can be easily manipulated. The only exceptions
|
||||
to this rule are 0 and 1, when used as false and true (respectively).
|
||||
Any other use of a numeric constant to specify different behavior
|
||||
or actions should be done through a #define.
|
||||
|
||||
[4] When writing functions that deal with strings, be sure to remember
|
||||
that PHP holds the length property of each string, and that it
|
||||
shouldn't be calculated with strlen(). Write your functions in a such
|
||||
a way so that they'll take advantage of the length property, both
|
||||
for efficiency and in order for them to be binary-safe.
|
||||
Functions that change strings and obtain their new lengths while
|
||||
doing so, should return that new length, so it doesn't have to be
|
||||
recalculated with strlen() (e.g. php_addslashes())
|
||||
|
||||
[5] Use php_error() to report any errors/warnings during code execution.
|
||||
Use descriptive error messages, and try to avoid using identical
|
||||
error strings for different stages of an error. For example,
|
||||
if in order to obtain a URL you have to parse the URL, connect,
|
||||
and retreive the text, assuming something can go wrong at each
|
||||
of these stages, don't report an error "Unable to get URL"
|
||||
on all of them, but instead, write something like "Unable
|
||||
to parse URL", "Unable to connect to URL server" and "Unable
|
||||
to fetch URL text", respectively.
|
||||
|
||||
[6] NEVER USE strncat(). If you're absolutely sure you know what you're doing,
|
||||
check its man page again, and only then, consider using it, and even then,
|
||||
try avoiding it.
|
||||
|
||||
[7] Use ZEND_* macros instead of PHP_* macros. Use of PHP_* macros is not
|
||||
recommended. Since most of the PHP_* macros are ZEND_* macro aliases, using
|
||||
the PHP_* macros makes browsing the source code with a tag search harder.
|
||||
|
||||
[8] Use assert(). assert.h is included in php.h if it is available. Not only
|
||||
does good assertion catch bugs, but it also helps with code readability.
|
||||
- Do not use assert for error handling. Use assert only for the
|
||||
condition that must be always true.
|
||||
- Do not use assignments in assert conditions. If you assign inside an
|
||||
assert condition, you risk an elusive bug that would be very difficult
|
||||
to spot in a debug build, due to the side effect of the assignment.
|
||||
Function calls in assert conditions may also cause this problem, if
|
||||
they modify one of their arguments or global variables.
|
||||
|
||||
Naming Conventions
|
||||
------------------
|
||||
|
||||
[1] Function names for user-level functions should be enclosed with in
|
||||
the PHP_FUNCTION() macro. They should be in lowercase, with words
|
||||
underscore delimited, with care taken to minimize the letter count.
|
||||
Abbreviations should not be used when they greatly decrease the
|
||||
readability of the function name itself.
|
||||
|
||||
Good:
|
||||
'mcrypt_enc_self_test'
|
||||
'mysql_list_fields'
|
||||
|
||||
Ok:
|
||||
'mcrypt_module_get_algo_supported_key_sizes'
|
||||
(could be 'mcrypt_mod_get_algo_sup_key_sizes'?)
|
||||
'get_html_translation_table'
|
||||
(could be 'html_get_trans_table'?)
|
||||
|
||||
Bad:
|
||||
'hw_GetObjectByQueryCollObj'
|
||||
'pg_setclientencoding'
|
||||
'jf_n_s_i'
|
||||
|
||||
|
||||
[2] If they are part of a "parent set" of functions, that parent should
|
||||
be included in the user function name, and should be clearly related
|
||||
to the parent program or function family. This should be in the form
|
||||
of parent_*.
|
||||
|
||||
A family of 'foo' functions, for example:
|
||||
Good:
|
||||
'foo_select_bar'
|
||||
'foo_insert_baz'
|
||||
'foo_delete_baz'
|
||||
|
||||
Bad:
|
||||
'fooselect_bar'
|
||||
'fooinsertbaz'
|
||||
'delete_foo_baz'
|
||||
|
||||
[3] Function names used by user functions should be prefixed
|
||||
with "_php_", and followed by a word or an underscore-delimited list of
|
||||
words, in lowercase letters, that describes the function. If applicable,
|
||||
they should be declared 'static'.
|
||||
|
||||
[4] Variable names must be meaningful. One letter variable names must be
|
||||
avoided, except for places where the variable has no real meaning or
|
||||
a trivial meaning (e.g. for (i=0; i<100; i++) ...).
|
||||
|
||||
[5] Variable names should be in lowercase. Use underscores to separate
|
||||
between words.
|
||||
|
||||
|
||||
Syntax and indentation
|
||||
----------------------
|
||||
|
||||
[1] Never use C++ style comments (i.e. // comment). Always use C-style
|
||||
comments instead. PHP is written in C, and is aimed at compiling
|
||||
under any ANSI-C compliant compiler. Even though many compilers
|
||||
accept C++-style comments in C code, you have to ensure that your
|
||||
code would compile with other compilers as well.
|
||||
The only exception to this rule is code that is Win32-specific,
|
||||
because the Win32 port is MS-Visual C++ specific, and this compiler
|
||||
is known to accept C++-style comments in C code.
|
||||
|
||||
[2] Use K&R-style. Of course, we can't and don't want to
|
||||
force anybody to use a style he or she is not used to, but,
|
||||
at the very least, when you write code that goes into the core
|
||||
of PHP or one of its standard modules, please maintain the K&R
|
||||
style. This applies to just about everything, starting with
|
||||
indentation and comment styles and up to function declaration
|
||||
syntax.
|
||||
|
||||
(see also http://www.tuxedo.org/~esr/jargon/html/entry/indent-style.html)
|
||||
|
||||
[3] Be generous with whitespace and braces. Always prefer:
|
||||
|
||||
if (foo) {
|
||||
bar;
|
||||
}
|
||||
|
||||
to:
|
||||
|
||||
if(foo)bar;
|
||||
|
||||
Keep one empty line between the variable declaration section and
|
||||
the statements in a block, as well as between logical statement
|
||||
groups in a block. Maintain at least one empty line between
|
||||
two functions, preferably two.
|
||||
|
||||
[4] When indenting, use the tab character. A tab is expected to represent
|
||||
four spaces. It is important to maintain consistency in indenture so
|
||||
that definitions, comments, and control structures line up correctly.
|
||||
|
||||
Documentation and Folding Hooks
|
||||
-------------------------------
|
||||
|
||||
In order to make sure that the online documentation stays in line with
|
||||
the code, each user-level function should have its user-level function
|
||||
prototype before it along with a brief one-line description of what the
|
||||
function does. It would look like this:
|
||||
|
||||
/* {{{ proto int abs(int number)
|
||||
Returns the absolute value of the number */
|
||||
PHP_FUNCTION(abs)
|
||||
{
|
||||
...
|
||||
}
|
||||
/* }}} */
|
||||
|
||||
The {{{ symbols are the default folding symbols for the folding mode in
|
||||
Emacs and vim (set fdm=marker). Folding is very useful when dealing with
|
||||
large files because you can scroll through the file quickly and just unfold
|
||||
the function you wish to work on. The }}} at the end of each function marks
|
||||
the end of the fold, and should be on a separate line.
|
||||
|
||||
The "proto" keyword there is just a helper for the doc/genfuncsummary script
|
||||
which generates a full function summary. Having this keyword in front of the
|
||||
function prototypes allows us to put folds elsewhere in the code without
|
||||
messing up the function summary.
|
||||
|
||||
Optional arguments are written like this:
|
||||
|
||||
/* {{{ proto object imap_header(int stream_id, int msg_no [, int from_length [, int subject_length [, string default_host]]])
|
||||
Returns a header object with the defined parameters */
|
||||
|
||||
And yes, please keep the prototype on a single line, even if that line
|
||||
is massive.
|
||||
|
||||
New and Experimental Functions
|
||||
-----------------------------------
|
||||
To reduce the problems normally associated with the first public
|
||||
implementation of a new set of functions, it has been suggested
|
||||
that the first implementation include a file labeled 'EXPERIMENTAL'
|
||||
in the function directory, and that the functions follow the
|
||||
standard prefixing conventions during their initial implementation.
|
||||
|
||||
The file labelled 'EXPERIMENTAL' should include the following
|
||||
information:
|
||||
Any authoring information (known bugs, future directions of the module).
|
||||
Ongoing status notes which may not be appropriate for CVS comments.
|
||||
|
||||
Aliases & Legacy Documentation
|
||||
-----------------------------------
|
||||
You may also have some deprecated aliases with close to duplicate
|
||||
names, for example, somedb_select_result and somedb_selectresult. For
|
||||
documentation purposes, these will only be documented by the most
|
||||
current name, with the aliases listed in the documentation for
|
||||
the parent function. For ease of reference, user-functions with
|
||||
completely different names, that alias to the same function (such as
|
||||
highlight_file and show_source), will be separately documented. The
|
||||
proto should still be included, describing which function is aliased.
|
||||
|
||||
Backwards compatible functions and names should be maintained as long
|
||||
as the code can be reasonably be kept as part of the codebase. See
|
||||
/phpdoc/README for more information on documentation.
|
||||
@@ -1,2 +0,0 @@
|
||||
For the list of people who've put work into PHP, please see
|
||||
http://www.php.net/credits.php
|
||||
Binary file not shown.
Binary file not shown.
Binary file not shown.
-473
@@ -1,473 +0,0 @@
|
||||
List of PHP maintainers
|
||||
=======================
|
||||
|
||||
Maintenance legend
|
||||
------------------
|
||||
Supported: Someone is actually paid to look after this.
|
||||
Maintained: Someone actually looks after it.
|
||||
Odd Fixes: It has a maintainer but they don't have time to do
|
||||
much other than throw the odd patch in. See below.
|
||||
Orphan: No current maintainer [but maybe you could take the
|
||||
role as you write your new code].
|
||||
Obsolete: Old code. Something tagged obsolete generally means
|
||||
it has been replaced by a better system and you
|
||||
should be using that.
|
||||
Unknown: Not known at this time.
|
||||
|
||||
Status legend
|
||||
-------------
|
||||
Working: Working under both Windows and Unix.
|
||||
Windows: Working only under Windows.
|
||||
Unix: Working only under Unix.
|
||||
Experimental: Under development or initial release.
|
||||
Not Working: Not working.
|
||||
Unknown: Status unknown.
|
||||
|
||||
|
||||
== Server APIs ==
|
||||
|
||||
-------------------------------------------------------------------------------
|
||||
EXTENSION: aolserver
|
||||
MAINTENANCE: Unknown
|
||||
STATUS: Unknown
|
||||
-------------------------------------------------------------------------------
|
||||
EXTENSION: apache
|
||||
PRIMARY MAINTAINER: Rasmus Lerdorf <rasmus@php.net>
|
||||
MAINTENANCE: Maintained
|
||||
STATUS: Working
|
||||
-------------------------------------------------------------------------------
|
||||
EXTENSION: apache2
|
||||
PRIMARY MAINTAINER: Aaron Bannert <aaron@php.net>
|
||||
MAINTENANCE: Maintained
|
||||
STATUS: Experimental
|
||||
-------------------------------------------------------------------------------
|
||||
EXTENSION: cgi
|
||||
MAINTENANCE: Unknown
|
||||
STATUS: Working
|
||||
-------------------------------------------------------------------------------
|
||||
EXTENSION: fhttpd
|
||||
MAINTENANCE: Unknown
|
||||
STATUS: Unknown
|
||||
-------------------------------------------------------------------------------
|
||||
EXTENSION: isapi
|
||||
MAINTENANCE: Unknown
|
||||
STATUS: Working
|
||||
-------------------------------------------------------------------------------
|
||||
EXTENSION: nsapi
|
||||
MAINTENANCE: Unknown
|
||||
STATUS: Unknown
|
||||
-------------------------------------------------------------------------------
|
||||
EXTENSION: phttpd
|
||||
MAINTENANCE: Unknown
|
||||
STATUS: Unknown
|
||||
-------------------------------------------------------------------------------
|
||||
EXTENSION: pi3web
|
||||
MAINTENANCE: Unknown
|
||||
STATUS: Unknown
|
||||
-------------------------------------------------------------------------------
|
||||
EXTENSION: roxen
|
||||
MAINTENANCE: Unknown
|
||||
STATUS: Unknown
|
||||
-------------------------------------------------------------------------------
|
||||
EXTENSION: servlet
|
||||
PRIMARY MAINTAINER: Sam Ruby <rubys@us.ibm.com>
|
||||
MAINTENANCE: Maintained
|
||||
STATUS: Working
|
||||
-------------------------------------------------------------------------------
|
||||
EXTENSION: thttpd
|
||||
MAINTENANCE: Unknown
|
||||
STATUS: Unknown
|
||||
-------------------------------------------------------------------------------
|
||||
EXTENSION: webjames
|
||||
PRIMARY MAINTAINER: Alex Waugh <alex@alexwaugh.com>
|
||||
MAINTENANCE: Maintained
|
||||
STATUS: Experimental
|
||||
-------------------------------------------------------------------------------
|
||||
|
||||
|
||||
== Database extensions ==
|
||||
|
||||
-------------------------------------------------------------------------------
|
||||
EXTENSION: dba
|
||||
PRIMARY MAINTAINER: Sascha Schumann <sascha@schumann.cx>
|
||||
MAINTENANCE: Maintained
|
||||
STATUS: Working
|
||||
-------------------------------------------------------------------------------
|
||||
EXTENSION: dbase
|
||||
PRIMARY MAINTAINER: Jim Winstead <jimw@php.net>
|
||||
MAINTENANCE: Odd Fixes
|
||||
STATUS: Working
|
||||
-------------------------------------------------------------------------------
|
||||
EXTENSION: dbx
|
||||
PRIMARY MAINTAINER: Marc Boeren <M.Boeren@guidance.nl>
|
||||
MAINTENANCE: Maintained
|
||||
STATUS: Working
|
||||
SINCE: 4.0.6
|
||||
COMMENT: DB abstraction for odbc, mysql, pgsql, mssql, fbsql and more, see documentation
|
||||
-------------------------------------------------------------------------------
|
||||
EXTENSION: filepro
|
||||
MAINTENANCE: Unknown
|
||||
STATUS: Unknown
|
||||
-------------------------------------------------------------------------------
|
||||
EXTENSION: hyperwave
|
||||
PRIMARY MAINTAINER: Uwe Steinmann <steinm@php.net>
|
||||
MAINTENANCE: Maintained
|
||||
STATUS: Working
|
||||
-------------------------------------------------------------------------------
|
||||
EXTENSION: informix
|
||||
PRIMARY MAINTAINER: Danny Heijl <Danny.Heijl@cevi.be>
|
||||
MAINTENANCE: Maintained
|
||||
STATUS: Working
|
||||
-------------------------------------------------------------------------------
|
||||
EXTENSION: ingres_ii
|
||||
PRIMARY MAINTAINER: David Hénot <henot@php.net>
|
||||
MAINTENANCE: Maintained
|
||||
STATUS: Experimental
|
||||
SINCE: 4.0.2
|
||||
-------------------------------------------------------------------------------
|
||||
EXTENSION: interbase
|
||||
PRIMARY MAINTAINER: Jouni Ahto <jouni.ahto@exdec.fi>
|
||||
MAINTENANCE: Odd Fixes
|
||||
STATUS: Working
|
||||
-------------------------------------------------------------------------------
|
||||
EXTENSION: msql
|
||||
MAINTENANCE: Unknown
|
||||
STATUS: Working
|
||||
-------------------------------------------------------------------------------
|
||||
EXTENSION: msession
|
||||
PRIMARY MAINTAINER Mark L. Woodward mlwmohawk@mohawksoft.com
|
||||
MAINTENANCE: Maintained
|
||||
STATUS: Working/Experimental
|
||||
COMMENT: Tested on Linux, should work on other UNIX platforms. Backend server code can compile under Windows.
|
||||
-------------------------------------------------------------------------------
|
||||
EXTENSION: mssql
|
||||
PRIMARY MAINTAINER: Frank M. Kromann <fmk@swwwing.com>
|
||||
MAINTENANCE: Maintained
|
||||
STATUS: Working
|
||||
COMMENT: Tested on phpts and isapi versions
|
||||
-------------------------------------------------------------------------------
|
||||
EXTENSION: mysql
|
||||
MAINTENANCE: Unknown
|
||||
STATUS: Working
|
||||
-------------------------------------------------------------------------------
|
||||
EXTENSION: pgsql
|
||||
PRIMARY MAINTAINER: Yasuo Ohgaki <yohgaki@php.net>
|
||||
MAINTENANCE: Maintained
|
||||
STATUS: Working
|
||||
COMMENT: Use PostgreSQL 7.0.x or later. PostgreSQL 6.5.3 or less have fatal bug.
|
||||
-------------------------------------------------------------------------------
|
||||
EXTENSION: sybase
|
||||
MAINTENANCE: Unknown
|
||||
STATUS: Not Working
|
||||
-------------------------------------------------------------------------------
|
||||
EXTENSION: sybase_ct
|
||||
MAINTENANCE: Unknown
|
||||
STATUS: Working
|
||||
-------------------------------------------------------------------------------
|
||||
EXTENSION: oci8
|
||||
PRIMARY MAINTAINER: Thies C. Arntzen <thies@thieso.net>
|
||||
MAINTENANCE: Maintained
|
||||
STATUS: Working
|
||||
-------------------------------------------------------------------------------
|
||||
EXTENSION: odbc
|
||||
PRIMARY MAINTAINER: Daniel R. Kalowsky <kalowsky@php.net>
|
||||
MAINTENANCE: Maintained
|
||||
STATUS: Working
|
||||
COMMENT: Working except for persistent connections
|
||||
-------------------------------------------------------------------------------
|
||||
EXTENSION: oracle
|
||||
PRIMARY MAINTAINER: Thies C. Arntzen <thies@thieso.net>
|
||||
MAINTENANCE: Maintained
|
||||
STATUS: Working
|
||||
COMMENT: Using the new OCI8 driver is encouraged where possible.
|
||||
-------------------------------------------------------------------------------
|
||||
|
||||
|
||||
== Other extensions ==
|
||||
|
||||
-------------------------------------------------------------------------------
|
||||
EXTENSION: aspell
|
||||
MAINTENANCE: Unknown
|
||||
STATUS: Working
|
||||
COMMENT: For aspell .27 and greater, check out the pspell extension
|
||||
-------------------------------------------------------------------------------
|
||||
EXTENSION: bcmath
|
||||
MAINTENANCE: Unknown
|
||||
STATUS: Unknown
|
||||
-------------------------------------------------------------------------------
|
||||
EXTENSION: bz2
|
||||
PRIMARY MAINTAINER: Sterling Hughes <sterling@php.net>
|
||||
MAINTENANCE: Maintained
|
||||
STATUS: Working
|
||||
SINCE: 4.0.3
|
||||
-------------------------------------------------------------------------------
|
||||
EXTENSION: calendar
|
||||
PRIMARY MAINTAINER: Hartmut Holzgraefe <hartmut@six.de>
|
||||
MAINTENANCE: Odd Fixes
|
||||
STATUS: Working
|
||||
-------------------------------------------------------------------------------
|
||||
EXTENSION: com
|
||||
PRIMARY MAINTAINER: Harald Radi <h.radi@nme.at>
|
||||
MAINTENANCE: Maintained
|
||||
STATUS: Working
|
||||
-------------------------------------------------------------------------------
|
||||
EXTENSION: cpdf
|
||||
PRIMARY MAINTAINER: Uwe Steinmann <steinm@php.net>
|
||||
MAINTENANCE: Maintained
|
||||
STATUS: Working
|
||||
-------------------------------------------------------------------------------
|
||||
EXTENSION: crack
|
||||
MAINTENANCE: Unknown
|
||||
STATUS: Experimental
|
||||
SINCE: 4.0.5
|
||||
-------------------------------------------------------------------------------
|
||||
EXTENSION: ctype
|
||||
PRIMARY MAINTAINER: Hartmut Holzgraefe <hartmut@six.de>
|
||||
MAINTENANCE: Maintained
|
||||
STATUS: Working
|
||||
-------------------------------------------------------------------------------
|
||||
EXTENSION: curl
|
||||
PRIMARY MAINTAINER: Sterling Hughes <sterling@php.net>
|
||||
MAINTENANCE: Maintained
|
||||
STATUS: Working
|
||||
SINCE: 4.0.2
|
||||
-------------------------------------------------------------------------------
|
||||
EXTENSION: cybercash
|
||||
PRIMARY MAINTAINER: Evan Klinger <evan715@sirius.com>
|
||||
MAINTENANCE: Maintained
|
||||
STATUS: Unknown
|
||||
-------------------------------------------------------------------------------
|
||||
EXTENSION: domxml
|
||||
PRIMARY MAINTAINER: Uwe Steinmann <steinm@php.net>
|
||||
MAINTENANCE: Maintained
|
||||
STATUS: Experimental
|
||||
-------------------------------------------------------------------------------
|
||||
EXTENSION: dotnet
|
||||
PRIMARY MAINTAINER: Sam Ruby <rubys@us.ibm.com>
|
||||
MAINTENANCE: Maintained
|
||||
STATUS: Experimental
|
||||
-------------------------------------------------------------------------------
|
||||
EXTENSION: exif
|
||||
PRIMARY MAINTAINER: Marcus Boerger <helly@php.net>
|
||||
MAINTENANCE: Maintained
|
||||
STATUS: Working
|
||||
SINCE: 4.2
|
||||
-------------------------------------------------------------------------------
|
||||
EXTENSION: fdf
|
||||
PRIMARY MAINTAINER: Uwe Steinmann <steinm@php.net>
|
||||
MAINTENANCE: Maintained
|
||||
STATUS: Unknown
|
||||
-------------------------------------------------------------------------------
|
||||
EXTENSION: ftp
|
||||
MAINTENANCE: Unknown
|
||||
STATUS: Unknown
|
||||
-------------------------------------------------------------------------------
|
||||
EXTENSION: gd
|
||||
PRIMARY MAINTAINER: Rasmus Lerdorf <rasmus@php.net>
|
||||
MAINTENANCE: Maintained
|
||||
STATUS: Working
|
||||
-------------------------------------------------------------------------------
|
||||
EXTENSION: gettext
|
||||
MAINTENANCE: Unknown
|
||||
STATUS: Working
|
||||
-------------------------------------------------------------------------------
|
||||
EXTENSION: gmp
|
||||
MAINTENANCE: Unknown
|
||||
STATUS: Unknown
|
||||
SINCE: 4.0.4
|
||||
-------------------------------------------------------------------------------
|
||||
EXTENSION: icap
|
||||
MAINTENANCE: Unknown
|
||||
STATUS: Obsolete
|
||||
-------------------------------------------------------------------------------
|
||||
EXTENSION: imap
|
||||
PRIMARY MAINTAINER: Chuck Hagenbuch <chuck@horde.org>
|
||||
MAINTENANCE: Odd Fixes
|
||||
STATUS: Working
|
||||
-------------------------------------------------------------------------------
|
||||
EXTENSION: java
|
||||
PRIMARY MAINTAINER: Sam Ruby <rubys@us.ibm.com>
|
||||
MAINTENANCE: Maintained
|
||||
STATUS: Working
|
||||
-------------------------------------------------------------------------------
|
||||
EXTENSION: ldap
|
||||
PRIMARY MAINTAINER: Stig Venaas <venaas@php.net>
|
||||
MAINTENANCE: Maintained
|
||||
STATUS: Working
|
||||
-------------------------------------------------------------------------------
|
||||
EXTENSION: mbstring
|
||||
PRIMARY MAINTAINER: Rui Hirokawa <hirokawa@php.net>
|
||||
MAINTENANCE: Maintained
|
||||
STATUS: Working
|
||||
-------------------------------------------------------------------------------
|
||||
EXTENSION: mcal
|
||||
PRIMARY MAINTAINER: Chuck Hagenbuch <chuck@horde.org>
|
||||
MAINTENANCE: Odd Fixes
|
||||
STATUS: Working
|
||||
-------------------------------------------------------------------------------
|
||||
EXTENSION: mcrypt
|
||||
PRIMARY MAINTAINER: Derick Rethans <d.rethans@jdimedia.nl>
|
||||
MAINTENANCE: Maintained
|
||||
STATUS: Working
|
||||
-------------------------------------------------------------------------------
|
||||
EXTENSION: mhash
|
||||
PRIMARY MAINTAINER: Sascha Schumann <sascha@schumann.cx>
|
||||
MAINTENANCE: Maintained
|
||||
STATUS: Working
|
||||
-------------------------------------------------------------------------------
|
||||
EXTENSION: muscat
|
||||
PRIMARY MAINTAINER: Sam Liddicott <sam@ananova.com>
|
||||
MAINTENANCE: Maintained
|
||||
STATUS: Working
|
||||
SINCE: 4.0.5
|
||||
COMMENT: Not tested against windows, only core API completed, rest under development
|
||||
-------------------------------------------------------------------------------
|
||||
EXTENSION: openssl
|
||||
PRIMARY MAINTAINER: Wez Furlong <wez@php.net>
|
||||
MAINTENANCE: Maintained
|
||||
STATUS: Experimental
|
||||
SINCE: 4.0.4
|
||||
-------------------------------------------------------------------------------
|
||||
EXTENSION: overload
|
||||
PRIMARY MAINTAINER: Andrei Zmievski <andrei@php.net>
|
||||
MAINTENANCE: Maintained
|
||||
STATUS: Experimental
|
||||
-------------------------------------------------------------------------------
|
||||
EXTENSION: pcre
|
||||
PRIMARY MAINTAINER: Andrei Zmievski <andrei@php.net>
|
||||
MAINTENANCE: Maintained
|
||||
STATUS: Working
|
||||
-------------------------------------------------------------------------------
|
||||
EXTENSION: pdf
|
||||
PRIMARY MAINTAINER: Uwe Steinmann <steinm@php.net>
|
||||
MAINTENANCE: Maintained
|
||||
STATUS: Working
|
||||
-------------------------------------------------------------------------------
|
||||
EXTENSION: pfpro
|
||||
PRIMARY MAINTAINER: David Croft <david@infotrek.co.uk>
|
||||
MAINTENANCE: Maintained
|
||||
STATUS: Working
|
||||
SINCE: 4.0.2
|
||||
-------------------------------------------------------------------------------
|
||||
EXTENSION: posix
|
||||
PRIMARY MAINTAINER: Kristian Köhntopp <kris@koehntopp.de>
|
||||
MAINTENANCE: Maintained
|
||||
STATUS: Working
|
||||
-------------------------------------------------------------------------------
|
||||
EXTENSION: printer
|
||||
PRIMARY MAINTAINER: Daniel Beulshausen <daniel@php4win.de>
|
||||
MAINTENANCE: Maintained
|
||||
STATUS: Working
|
||||
SINCE: 4.0.4
|
||||
COMMENT: Only for Win32
|
||||
-------------------------------------------------------------------------------
|
||||
EXTENSION: pspell
|
||||
PRIMARY MAINTAINER: Vlad Krupin <phpdevel@echospace.com>
|
||||
MAINTENANCE: Unknown
|
||||
STATUS: Unknown
|
||||
SINCE: 4.0.2
|
||||
-------------------------------------------------------------------------------
|
||||
EXTENSION: qtdom
|
||||
MAINTENANCE: Unknown
|
||||
STATUS: Experimental
|
||||
SINCE: 4.0.4
|
||||
-------------------------------------------------------------------------------
|
||||
EXTENSION: readline
|
||||
MAINTENANCE: Unknown
|
||||
STATUS: Unknown
|
||||
-------------------------------------------------------------------------------
|
||||
EXTENSION: recode
|
||||
PRIMARY MAINTAINER: Kristian Köhntopp <kris@koehntopp.de>
|
||||
MAINTENANCE: Maintained
|
||||
STATUS: Working
|
||||
-------------------------------------------------------------------------------
|
||||
EXTENSION: sablot
|
||||
PRIMARY MAINTAINER: Sterling Hughes <sterling@php.net>
|
||||
MAINTENANCE: Obsolete
|
||||
STATUS: Experimental
|
||||
SINCE: 4.0.3
|
||||
-------------------------------------------------------------------------------
|
||||
EXTENSION: satellite
|
||||
PRIMARY MAINTAINER: David Eriksson <eriksson@php.net>
|
||||
MAINTENANCE: Odd Fixes
|
||||
STATUS: Experimental
|
||||
SINCE: 4.0.3
|
||||
-------------------------------------------------------------------------------
|
||||
EXTENSION: session
|
||||
PRIMARY MAINTAINER: Sascha Schumann <sascha@schumann.cx>
|
||||
MAINTENANCE: Maintained
|
||||
STATUS: Working
|
||||
-------------------------------------------------------------------------------
|
||||
EXTENSION: shmop
|
||||
PRIMARY MAINTAINER: Ilia Alshanetsky <iliaa@php.net>
|
||||
MAINTENANCE: Maintained
|
||||
STATUS: Experimental
|
||||
SINCE: 4.0.3
|
||||
-------------------------------------------------------------------------------
|
||||
EXTENSION: snmp
|
||||
PRIMARY MAINTAINER: Rasmus Lerdorf <rasmus@php.net>
|
||||
MAINTENANCE: Odd Fixes
|
||||
STATUS: Working
|
||||
-------------------------------------------------------------------------------
|
||||
EXTENSION: sockets
|
||||
PRIMARY MAINTAINER: Chris Vandomelen <chrisv@b0rked.dhs.org>
|
||||
MAINTENANCE: Maintained
|
||||
STATUS: Experimental
|
||||
SINCE: 4.0.2
|
||||
-------------------------------------------------------------------------------
|
||||
EXTENSION: swf
|
||||
PRIMARY MAINTAINER: Sterling Hughes <sterling@php.net>
|
||||
MAINTENANCE: Maintained
|
||||
STATUS: Depreciated (Use the ming swf extension instead)
|
||||
COMMENT: Only for Unix (won't change)
|
||||
-------------------------------------------------------------------------------
|
||||
EXTENSION: sysvsem
|
||||
MAINTENANCE: Unknown
|
||||
STATUS: Unknown
|
||||
-------------------------------------------------------------------------------
|
||||
EXTENSION: sysvshm
|
||||
MAINTENANCE: Unknown
|
||||
STATUS: Working
|
||||
-------------------------------------------------------------------------------
|
||||
EXTENSION: vpopmail
|
||||
MAINTENANCE: Unknown
|
||||
STATUS: Experimental
|
||||
SINCE: 4.0.5
|
||||
-------------------------------------------------------------------------------
|
||||
EXTENSION: wddx
|
||||
PRIMARY MAINTAINER: Andrei Zmievski <andrei@php.net>
|
||||
MAINTENANCE: Maintained
|
||||
STATUS: Working
|
||||
-------------------------------------------------------------------------------
|
||||
EXTENSION: xml
|
||||
PRIMARY MAINTAINER: Thies C. Arntzen <thies@thieso.net>
|
||||
MAINTENANCE: Maintained
|
||||
STATUS: Working
|
||||
-------------------------------------------------------------------------------
|
||||
EXTENSION: xslt
|
||||
PRIMARY MAINTAINER: Sterling Hughes <sterling@php.net>
|
||||
MAINTENANC: Maintained
|
||||
STATUS: Working
|
||||
-------------------------------------------------------------------------------
|
||||
EXTENSION: yaz
|
||||
PRIMARY MAINTAINER: Adam Dickmeiss <adam@indexdata.dk>
|
||||
MAINTENANCE: Maintained
|
||||
STATUS: Unknown
|
||||
SINCE: 4.0.1
|
||||
-------------------------------------------------------------------------------
|
||||
EXTENSION: yp
|
||||
MAINTENANCE: Unknown
|
||||
STATUS: Unknown
|
||||
-------------------------------------------------------------------------------
|
||||
EXTENSION: zlib
|
||||
PRIMARY MAINTAINER: Stefan Roehrich <sr@linux.de>
|
||||
MAINTENANCE: Maintained
|
||||
STATUS: Working
|
||||
-------------------------------------------------------------------------------
|
||||
EXTENSION: zziplib
|
||||
PRIMARY MAINTAINER: Sterling Hughes <sterling@php.net>
|
||||
MAINTENANCE: Maintained
|
||||
STATUS: Experimental
|
||||
SINCE: 4.0.5
|
||||
-------------------------------------------------------------------------------
|
||||
# iptc?
|
||||
@@ -1,411 +0,0 @@
|
||||
Installation Instructions for PHP 4
|
||||
-----------------------------------
|
||||
|
||||
STOP!
|
||||
|
||||
Before going any further, please remember you are going to find more
|
||||
up to date instructions in the online manual, located here:
|
||||
|
||||
http://www.php.net/manual/en/install.apache.php
|
||||
|
||||
It is strongly recommended that you read the manual page before going
|
||||
further. However, for the impatient, here is a quick set of steps that
|
||||
will build PHP as (first) a dynamic Apache module (DSO) for Apache 1.3.x
|
||||
with MySQL support and then a static module. A more verbose explanation follows.
|
||||
|
||||
For installing PHP on other web servers, refer to one of the following
|
||||
files:
|
||||
|
||||
sapi/aolserver/README
|
||||
sapi/pi3web/README
|
||||
sapi/servlet/README
|
||||
sapi/thttpd/README
|
||||
README.Zeus
|
||||
|
||||
Some notes:
|
||||
|
||||
1: Only install either the static module or the dynamic one. Do not
|
||||
install both.
|
||||
|
||||
2: If you are recompiling PHP to add new extensions or upgrading
|
||||
something like GD, remove the config.cache file before you re-run
|
||||
configure.
|
||||
|
||||
3: If you are on Linux and have installed shared libraries, make
|
||||
sure the location of these shared libraries are listed in your
|
||||
/etc/ld.so.conf file. For example, if you have:
|
||||
|
||||
/usr/local/lib/mysql/libmysqlclient.so
|
||||
|
||||
Make sure /etc/ld.so.conf contains:
|
||||
|
||||
/usr/local/lib/mysql
|
||||
|
||||
Then run ldconfig.
|
||||
|
||||
If you want both PHP 3 and 4 modules in the same Apache server, check the
|
||||
bottom of this file for instructions.
|
||||
|
||||
INSTALLATION WITH THE ZEUS WEB SERVER:
|
||||
--Please see the 'README.Zeus' file included in this distribution
|
||||
|
||||
|
||||
QUICK INSTALL (DSO)
|
||||
|
||||
For this to work your Apache httpd must have mod_so enabled.
|
||||
Check using httpd -l. You should see something like:
|
||||
|
||||
Compiled-in modules:
|
||||
http_core.c
|
||||
mod_so.c
|
||||
|
||||
Chances are you will see a lot more modules than these two. That's ok,
|
||||
as long as mod_so.c shows up you can proceed with the following steps:
|
||||
|
||||
$ gunzip -c php-4.x.y.tar.gz | tar xf -
|
||||
$ cd php-4.x.y
|
||||
$ ./configure --with-mysql --with-apxs
|
||||
$ make
|
||||
$ make install
|
||||
|
||||
If you get an error telling you that the apxs script could not be found,
|
||||
look for it on your system and if you find it, provide the full path to it
|
||||
as: --with-apxs=/path/to/apxs
|
||||
|
||||
Next you must copy php.ini-dist to the appropriate place (normally
|
||||
/usr/local/lib/php.ini) and edit it as necessary to set PHP options.
|
||||
|
||||
The only thing left to do is to edit your httpd.conf file and make sure the
|
||||
PHP 4 mime type is there and uncommented. You need a line that looks like
|
||||
this:
|
||||
|
||||
AddType application/x-httpd-php .php
|
||||
|
||||
Then restart your server (apachectl restart) and you should be able to
|
||||
serve up PHP files now. Make a test file called test.php and put some
|
||||
PHP tags in it. Like <?phpinfo()?>, for example.
|
||||
|
||||
|
||||
QUICK INSTALL (Static)
|
||||
|
||||
$ gunzip -c apache_1.3.x.tar.gz | tar xf -
|
||||
$ cd apache_1.3.x
|
||||
$ ./configure
|
||||
$ cd ..
|
||||
|
||||
$ gunzip -c php-4.x.y.tar.gz | tar xf -
|
||||
$ cd php-4.x.y
|
||||
$ ./configure --with-mysql --with-apache=../apache_1.3.x
|
||||
$ make
|
||||
$ make install
|
||||
|
||||
$ cd ../apache_1.3.x
|
||||
$ ./configure --prefix=/www --activate-module=src/modules/php4/libphp4.a
|
||||
(The above line is correct! Yes, we know libphp4.a does not exist at this
|
||||
stage. It isn't supposed to. It will be created.)
|
||||
$ make
|
||||
(you should now have an httpd binary which you can copy to your Apache bin dir if
|
||||
is is your first install then you need to "make install" as well)
|
||||
$ cd ../php-4.x.y
|
||||
$ cp php.ini-dist /usr/local/lib/php.ini
|
||||
You can edit /usr/local/lib/php.ini file to set PHP options.
|
||||
Edit your httpd.conf or srm.conf file and add:
|
||||
AddType application/x-httpd-php .php
|
||||
|
||||
|
||||
VERBOSE INSTALL
|
||||
|
||||
Chances are you are reading this because the quick install steps above
|
||||
did not work for you. If this is the case, congratulations, you are
|
||||
among the elite few that actually reads documentation. It really is
|
||||
not a difficult install and once you have done it once you will fly
|
||||
through it.
|
||||
|
||||
Installing PHP can be done in four simple steps:
|
||||
|
||||
1. Unpack your distribution file.
|
||||
|
||||
You will have downloaded a file named something like php-4.x.y.tar.gz.
|
||||
Unzip this file with a command like: gunzip php-4.x.y.tar.gz
|
||||
|
||||
Next you have to untar it with: tar -xvf php-4.x.y.tar
|
||||
|
||||
This will create a php-4.x.y directory. cd into this new directory.
|
||||
|
||||
2a. Configure PHP (Dynamic Module) - Skip to 2b if you wish to build
|
||||
a static module
|
||||
|
||||
You now have to choose the options you would like. There are quite
|
||||
a few of them. To see a list, type: ./configure --help
|
||||
|
||||
The only options that you are likely to want to use are the ones in
|
||||
the last section entitled, "--enable and --with options recognized:"
|
||||
|
||||
A popular choice is to build the Apache module version. In order to
|
||||
build PHP as a dynamic module for Apache-1.3.x you have to first have
|
||||
Apache installed. Assuming Apache is already installed, make sure
|
||||
the shared object module is enabled. To check this, type: httpd -l
|
||||
You should see something like:
|
||||
|
||||
Compiled-in modules:
|
||||
http_core.c
|
||||
mod_so.c
|
||||
|
||||
You will most likely have a lot more modules than what is shown here.
|
||||
As long as mod_so.c shows up in the list, PHP should be happy.
|
||||
|
||||
Now, type: ./configure --with-mysql --with-apxs
|
||||
|
||||
If you get an error telling you that the apxs script could not be found,
|
||||
look for it on your system and if you find it, provide the full path to it
|
||||
as: --with-apxs=/path/to/apxs
|
||||
|
||||
You might also want other flags on this configure line. --with-mysql
|
||||
is just an example.
|
||||
|
||||
There are a few things that can go wrong during this configure step.
|
||||
The most common is that you have asked for an option and that the
|
||||
configure script can not find the files required to enable this
|
||||
option in PHP. Chances are you can provide the full path to the
|
||||
base directory under which the related files were installed. For
|
||||
example, if you have installed the GD library in /opt/gd which means
|
||||
that /opt/gd/include has your GD header files and /opt/gd/lib contains
|
||||
your GD library files, you would use --with-gd=/opt/gd
|
||||
|
||||
Skip to step 3 for compilation and installation instructions.
|
||||
|
||||
2b. Configure PHP (Static Module) - Skip if you performed 2a
|
||||
|
||||
You now have to choose the options you would like. There are quite
|
||||
a few of them. To see a list, type: ./configure --help
|
||||
|
||||
The only options that you are likely to want to use are the ones in
|
||||
the last section entitled, "--enable and --with options recognized:"
|
||||
|
||||
A popular choice is to build the Apache module version. You need
|
||||
to know where the source code directory for your Apache server is
|
||||
located. Then use an option like: --with-apache=/usr/local/src/apache
|
||||
if that is your Apache source code directory. If you only specify
|
||||
--with-apache, then it will default to look for your Apache source
|
||||
in /usr/local/etc/httpd.
|
||||
|
||||
NOTE: The directory you specify should be the top-level of the
|
||||
unpacked Apache (or Stronghold) distribution. The configure program
|
||||
will automatically look for httpd.h in different directories under that
|
||||
location depending on which version of Apache, including Stronghold,
|
||||
you are running.
|
||||
|
||||
For MySQL support, since newer versions of MySQL installs its various
|
||||
components under /usr/local, this is the default. If you have
|
||||
changed the location you can specify it with: --with-mysql=/opt/local
|
||||
for example. Otherwise just use: --with-mysql
|
||||
|
||||
*NOTE* If you are using Apache 1.3b6 or later, you should run the
|
||||
Apache Configure script at least once before compiling PHP. It
|
||||
doesn't matter how you have Apache configured at this point.
|
||||
|
||||
Skip to step 3b at this point.
|
||||
|
||||
3. Compile and install the files. Simply type: make install
|
||||
|
||||
3a. Dynamic Module Installation
|
||||
|
||||
Nothing else is needed here. Proceed to step 4a.
|
||||
|
||||
3b. Static Module Installation
|
||||
|
||||
For the Apache module version this will copy the appropriate files
|
||||
to the src/modules/php4 directory in your Apache distribution if
|
||||
you are using Apache 1.3.x. If you are still running Apache 1.2.x
|
||||
these files will be copied directly to the main src directory.
|
||||
|
||||
For Apache 1.3b6 and later, you can use the new APACI configuration
|
||||
mechanism. To automatically build Apache with PHP support, use:
|
||||
|
||||
cd apache_1.3.x
|
||||
./configure --prefix=/<path>/apache \
|
||||
--activate-module=src/modules/php4/libphp4.a
|
||||
make
|
||||
make install
|
||||
|
||||
If you do not wish to use this new configuration tool, the old
|
||||
install procedure (src/Configure) will work fine.
|
||||
|
||||
If you are using the old Apache ./Configure script, you will have to
|
||||
edit the Apache src/Configuration file manually. If you do not have
|
||||
this file, copy Configuration.tmpl to Configuration.
|
||||
|
||||
For Apache 1.3.x add:
|
||||
|
||||
AddModule modules/php4/libphp4.a
|
||||
|
||||
For Apache 1.3.x don't do anything else. Just add this line and then
|
||||
run "./Configure" followed by "make".
|
||||
|
||||
For Apache 1.2.x add:
|
||||
|
||||
Module php4_module mod_php4.o
|
||||
|
||||
For Apache 1.2.x you will also have to look in the libphp4.module file,
|
||||
which was copied to the src directory. The EXTRA_LIBS line in the Apache
|
||||
Configuration file needs to be set to use the same libs as specified on
|
||||
the LIBS line in libphp4.module. You also need to make sure to add
|
||||
"-L." to the beginning of the EXTRA_LIBS line.
|
||||
|
||||
So, as an example, your EXTRA_LIBS line might look like:
|
||||
|
||||
EXTRA_LIBS=-L. -lphp4 -lgdbm -ldb -L/usr/local/mysql/lib -lmysqlclient
|
||||
|
||||
NOTE: You should not enclose the EXTRA_LIBS line in double-quotes, as it
|
||||
is in the libphp4.module file.
|
||||
|
||||
Also, look at the RULE_WANTHSREGEX setting in the libphp4.module file
|
||||
and set the WANTHSREGEX directive accordingly in your Configuration file.
|
||||
This last step applies to versions of Apache prior to 1.3b3.
|
||||
|
||||
This is a bit of a hassle, but should serve as incentive to move to
|
||||
Apache 1.3.x where this step has been eliminated.
|
||||
|
||||
Once you are satisfied with your Configuration settings, type: ./Configure
|
||||
If you get errors, chances are that you forgot a library or made a typo
|
||||
somewhere. Re-edit Configuration and try again. If it goes well,
|
||||
type: make
|
||||
|
||||
Assuming it compiles without errors, proceed to step 4b.
|
||||
|
||||
4a. Setting up the server. (Dynamic Module)
|
||||
|
||||
The make install command in step 3 should have done most of your
|
||||
work for you. It actually edits your httpd.conf file and tries to
|
||||
enable the dynamic PHP module. To verify this, look for a line that
|
||||
looks like this:
|
||||
|
||||
LoadModule php4_module libexec/libphp4.so
|
||||
|
||||
The actual path before the libphp4.so part might differ slightly. This
|
||||
is likely fine. If you are paranoid you can examine the output from the
|
||||
make install step to see where the libphp4.so file was actually put and
|
||||
place the full path to this file on this LoadModule line.
|
||||
|
||||
If somewhere in your httpd.conf file you have a ClearModuleList line
|
||||
then you also need this line:
|
||||
|
||||
AddModule mod_php4.c
|
||||
|
||||
And finally you need to tell Apache which file extension should trigger
|
||||
PHP. You do this by creating a special mime type and associating it
|
||||
with an extension. We suggest using:
|
||||
|
||||
AddType application/x-httpd-php .php
|
||||
|
||||
You are however free to use any extension you wish, including .html.
|
||||
|
||||
Note! If a line has a # at the beginning, then it is commented out
|
||||
and you need to remove the # for that line to take effect.
|
||||
|
||||
Finally you need to copy php.ini-dist to the appropriate place
|
||||
(normally /usr/local/lib/php.ini) and edit if necessary.
|
||||
|
||||
Once you have made these changes you should be ready to restart your
|
||||
server and try it out. Type: apachectl restart
|
||||
|
||||
4b. Setting up the server. (Static Module)
|
||||
|
||||
You should now have a new httpd binary. Shut down your existing server,
|
||||
if you have one, and copy this new binary overtop of it. Perhaps make
|
||||
a backup of your previous one first. Then edit your conf/httpd.conf file
|
||||
and add the line:
|
||||
|
||||
AddType application/x-httpd-php .php
|
||||
|
||||
There is also an interesting feature which can be quite instructive and
|
||||
helpful while debugging. That is the option of having colour syntax
|
||||
highlighting. To enable this, add the following line:
|
||||
|
||||
AddType application/x-httpd-php-source .phps
|
||||
|
||||
Any file ending in .phps will now be displayed with full colour syntax
|
||||
highlighting instead of being executed.
|
||||
|
||||
Note that on some older server setups, the AddType lines are in the
|
||||
conf/srm.conf file instead of conf/httpd.conf.
|
||||
|
||||
Note! If a line has a # at the beginning, then it is commented out
|
||||
and you need to remove the # for that line to take effect.
|
||||
|
||||
When you are finished making changes to your httpd.conf file, you need
|
||||
to copy php.ini-dist to the appropriate place (normally
|
||||
/usr/local/lib/php.ini) and edit if necessary. You can then
|
||||
start up your server.
|
||||
|
||||
5. Testing it all worked
|
||||
|
||||
Create a test file named test.php in your web tree somewhere and
|
||||
put some test PHP tags in it. <?phpinfo()?> is a good first test.
|
||||
This tag tells PHP to do a braindump and tells you all sorts of things
|
||||
about itself.
|
||||
|
||||
|
||||
WHY DISABLING -fPIC WORKS ON LINUX
|
||||
|
||||
From: Martin v. Loewis <martin@loewis.home.cs.tu-berlin.de>
|
||||
To: glibc-linux@ricardo.ecn.wfu.edu
|
||||
Subject: Re: Shared library -shared vs. -fpic
|
||||
|
||||
[In reply to Kaz Kylheku <kaz@ashi.footprints.net>]
|
||||
|
||||
> PIC stands for Position-Independent Code.
|
||||
|
||||
Correct.
|
||||
|
||||
> Code isn't position-independent (or ``relocatable'') cannot be
|
||||
> loaded at an arbitrary address;
|
||||
|
||||
Wrong.
|
||||
|
||||
> it requires some references to be patched at load time.
|
||||
|
||||
Correct.
|
||||
|
||||
> Shared libraries need to be relocatable because it's not known
|
||||
> beforehand what address they will be loaded at
|
||||
|
||||
Correct, depending on the meaning of "relocatable". PIC code typically
|
||||
does not contain relocations; that's why its position-independent.
|
||||
|
||||
> Just because you don't specify -fPIC doesn't mean that the compiler
|
||||
> won't emit position-independent code; the option prevents it from
|
||||
> emitting position-dependent code in situations where it otherwise
|
||||
> would.
|
||||
|
||||
Correct. However, a non-trivial shared library typically won't be
|
||||
position-independent unless explicitly compiled with
|
||||
-fPIC. Linux/glibc indeed does not require a shared library to be
|
||||
position-independent; instead, it will perform the relocations in the
|
||||
binary, even if they refer to code pages. As a result, those relocated
|
||||
pages won't be shared across processes, anymore.
|
||||
|
||||
Regards,
|
||||
Martin
|
||||
|
||||
USING PHP 3 AND PHP 4 AS CONCURRENT APACHE MODULES
|
||||
|
||||
With some (newer) installations of Apache, it's possible to compile both
|
||||
PHP 3 and PHP 4, and run them concurrently.
|
||||
|
||||
Note, it's only really wise to do this if you need to use the PHP 3 engine
|
||||
to maintain backwards compatibility.
|
||||
|
||||
To enable it, configure PHP 3 and PHP 4 to use APXS (--with-apxs) and the
|
||||
necessary link extensions (--enable-versioning). Otherwise, all standard
|
||||
installations instructions apply. For example:
|
||||
|
||||
$ ./configure \
|
||||
--with-apxs=/apache/bin/apxs \
|
||||
--enable-versioning \
|
||||
--with-mysql \
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -1,64 +0,0 @@
|
||||
--------------------------------------------------------------------
|
||||
The PHP License, version 3.0a1
|
||||
Copyright (c) 1999 - 2002 The PHP Group. All rights reserved.
|
||||
--------------------------------------------------------------------
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, is permitted provided that the following conditions
|
||||
are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright
|
||||
notice, this list of conditions and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above
|
||||
copyright notice, this list of conditions and the following
|
||||
disclaimer in the documentation and/or other materials provided
|
||||
with the distribution.
|
||||
|
||||
3. The name "PHP" must not be used to endorse or promote products
|
||||
derived from this software without prior permission from the
|
||||
PHP Group. This does not apply to add-on libraries or tools
|
||||
that work in conjunction with PHP. In such a case the PHP
|
||||
name may be used to indicate that the product supports PHP.
|
||||
|
||||
4. The PHP Group may publish revised and/or new versions of the
|
||||
license from time to time. Each version will be given a
|
||||
distinguishing version number.
|
||||
Once covered code has been published under a particular version
|
||||
of the license, you may always continue to use it under the
|
||||
terms of that version. You may also choose to use such covered
|
||||
code under the terms of any subsequent version of the license
|
||||
published by the PHP Group. No one other than the PHP Group has
|
||||
the right to modify the terms applicable to covered code created
|
||||
under this License.
|
||||
|
||||
5. Redistributions of any form whatsoever must retain the following
|
||||
acknowledgment:
|
||||
"This product includes PHP, freely available from
|
||||
http://www.php.net/".
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE PHP DEVELOPMENT TEAM ``AS IS'' AND
|
||||
ANY EXPRESSED 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 THE PHP
|
||||
DEVELOPMENT TEAM OR ITS 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.
|
||||
|
||||
--------------------------------------------------------------------
|
||||
|
||||
This software consists of voluntary contributions made by many
|
||||
individuals on behalf of the PHP Group.
|
||||
|
||||
The PHP Group can be contacted via Email at group@php.net.
|
||||
|
||||
For more information on the PHP Group and the PHP project,
|
||||
please see <http://www.php.net>.
|
||||
|
||||
This product includes the Zend Engine, freely available at
|
||||
<http://www.zend.com>.
|
||||
@@ -1,18 +0,0 @@
|
||||
$(builddir)/zend_language_scanner.lo: $(builddir)/zend_language_parser.h
|
||||
$(builddir)/zend_ini_scanner.lo: $(builddir)/zend_ini_parser.h
|
||||
|
||||
$(builddir)/zend_language_scanner.c: $(srcdir)/zend_language_scanner.l
|
||||
$(LEX) -Pzend -S$(srcdir)/flex.skl -o$@ -i $(srcdir)/zend_language_scanner.l
|
||||
|
||||
$(builddir)/zend_language_parser.h: $(builddir)/zend_language_parser.c
|
||||
$(builddir)/zend_language_parser.c: $(srcdir)/zend_language_parser.y
|
||||
$(YACC) -p zend -v -d $(srcdir)/zend_language_parser.y -o $@
|
||||
|
||||
$(builddir)/zend_ini_parser.h: $(builddir)/zend_ini_parser.c
|
||||
$(builddir)/zend_ini_parser.c: $(srcdir)/zend_ini_parser.y
|
||||
$(YACC) -p ini_ -v -d $(srcdir)/zend_ini_parser.y -o $@
|
||||
|
||||
$(builddir)/zend_ini_scanner.c: $(srcdir)/zend_ini_scanner.l
|
||||
$(LEX) -Pini_ -S$(srcdir)/flex.skl -o$@ -i $(srcdir)/zend_ini_scanner.l
|
||||
|
||||
$(builddir)/zend_indent.lo $(builddir)/zend_highlight.lo $(builddir)/zend_compile.lo: $(builddir)/zend_language_parser.h
|
||||
@@ -1,72 +0,0 @@
|
||||
mkinstalldirs = $(top_srcdir)/build/shtool mkdir -p
|
||||
INSTALL = $(top_srcdir)/build/shtool install -c
|
||||
INSTALL_DATA = $(INSTALL) -m 644
|
||||
|
||||
DEFS = -DPHP_ATOM_INC -I$(top_builddir)/include -I$(top_builddir)/main -I$(top_srcdir)
|
||||
COMMON_FLAGS = $(DEFS) $(INCLUDES) $(EXTRA_INCLUDES) $(CPPFLAGS)
|
||||
|
||||
|
||||
all: $(all_targets)
|
||||
|
||||
build-modules: $(PHP_MODULES)
|
||||
|
||||
libphp4.la: $(PHP_GLOBAL_OBJS) $(PHP_SAPI_OBJS)
|
||||
$(LIBTOOL) --mode=link $(CC) $(COMMON_FLAGS) $(CFLAGS) $(EXTRA_CFLAGS) -rpath $(phptempdir) $(EXTRA_LDFLAGS) $(LDFLAGS) $(PHP_RPATHS) $(PHP_GLOBAL_OBJS) $(PHP_SAPI_OBJS) $(EXTRA_LIBS) $(ZEND_EXTRA_LIBS) -o $@
|
||||
|
||||
libs/libphp4.bundle: $(PHP_GLOBAL_OBJS) $(PHP_SAPI_OBJS)
|
||||
$(CC) $(MH_BUNDLE_FLAGS) $(CFLAGS_CLEAN) $(EXTRA_CFLAGS) $(LDFLAGS) $(EXTRA_LDFLAGS) $(PHP_GLOBAL_OBJS:.lo=.o) $(PHP_SAPI_OBJS:.lo=.o) $(EXTRA_LIBS) $(ZEND_EXTRA_LIBS) -o $@ && cp $@ libs/libphp4.so
|
||||
|
||||
php: $(PHP_GLOBAL_OBJS) $(PHP_SAPI_OBJS)
|
||||
$(LIBTOOL) --mode=link $(CC) -export-dynamic $(COMMON_FLAGS) $(CFLAGS_CLEAN) $(EXTRA_CFLAGS) $(EXTRA_LDFLAGS) $(LDFLAGS) $(PHP_RPATHS) $(PHP_GLOBAL_OBJS) $(PHP_SAPI_OBJS) $(EXTRA_LIBS) $(ZEND_EXTRA_LIBS) -o $@
|
||||
|
||||
sapi/cli/php: $(PHP_GLOBAL_OBJS) $(PHP_CLI_OBJS)
|
||||
$(LIBTOOL) --mode=link $(CC) -export-dynamic $(COMMON_FLAGS) $(CFLAGS_CLEAN) $(EXTRA_CFLAGS) $(EXTRA_LDFLAGS) $(LDFLAGS) $(PHP_RPATHS) $(PHP_GLOBAL_OBJS) $(PHP_CLI_OBJS) $(EXTRA_LIBS) $(ZEND_EXTRA_LIBS) -o $@
|
||||
|
||||
install: $(install_targets)
|
||||
|
||||
|
||||
install-cli: sapi/cli/php
|
||||
$(INSTALL_CLI)
|
||||
|
||||
install-sapi: libphp4.la
|
||||
-@$(LIBTOOL) --silent --mode=install cp libphp4.la $(phptempdir)/libphp4.la >/dev/null 2>&1
|
||||
-@$(mkinstalldirs) $(INSTALL_ROOT)$(bindir)
|
||||
-@if test ! -r $(phptempdir)/libphp4.$(SHLIB_SUFFIX_NAME); then \
|
||||
for i in 0.0.0 0.0 0; do \
|
||||
if test -r $(phptempdir)/libphp4.$(SHLIB_SUFFIX_NAME).$$i; then \
|
||||
$(LN_S) $(phptempdir)/libphp4.$(SHLIB_SUFFIX_NAME).$$i $(phptempdir)/libphp4.$(SHLIB_SUFFIX_NAME); \
|
||||
break; \
|
||||
fi; \
|
||||
done; \
|
||||
fi
|
||||
$(INSTALL_IT)
|
||||
|
||||
install-modules: build-modules
|
||||
@test -d modules && \
|
||||
$(mkinstalldirs) $(INSTALL_ROOT)$(EXTENSION_DIR) && \
|
||||
echo "installing shared modules into $(EXTENSION_DIR)" && \
|
||||
rm -f modules/*.la && \
|
||||
cp modules/* $(INSTALL_ROOT)$(EXTENSION_DIR) >/dev/null 2>&1 || true
|
||||
|
||||
install-tester:
|
||||
@echo "Installing regression tester"
|
||||
@$(mkinstalldirs) $(PEAR_INSTALLDIR)
|
||||
@$(INSTALL) -m 755 $(top_srcdir)/run-tests.php $(INSTALL_ROOT)$(PEAR_INSTALLDIR)
|
||||
|
||||
install-su: install-pear install-tester
|
||||
|
||||
test: sapi/cli/php
|
||||
@TEST_PHP_EXECUTABLE=$(top_builddir)/sapi/cli/php \
|
||||
$(top_builddir)/sapi/cli/php -c php.ini-dist $(top_srcdir)/run-tests.php
|
||||
|
||||
clean:
|
||||
find . -follow -name \*.lo -o -name \*.o -o -name \*.la -o -name \*.a| xargs rm -f
|
||||
find . -follow -name .libs -a -type d|xargs rm -rf
|
||||
rm -f libphp4.la php sapi/cli/php modules/* libs/*
|
||||
|
||||
distclean: clean
|
||||
rm -f config.cache config.log config.status Makefile.objects Makefile.fragments libtool main/php_config.h stamp-h php4.spec sapi/apache/libphp4.module buildmk.stamp
|
||||
find . -name Makefile | xargs rm -f
|
||||
|
||||
.PHONY: all clean install distclean test
|
||||
.NOEXPORT:
|
||||
@@ -1,115 +0,0 @@
|
||||
This is the first file you should be reading after you get your CVS account.
|
||||
We'll assume you're basically familiar with CVS, but feel free to post
|
||||
your questions on the mailing list. Please have a look at
|
||||
http://cvsbook.red-bean.com/ for more detailed information on CVS.
|
||||
|
||||
PHP is developed through the efforts of a large number of people.
|
||||
Collaboration is a Good Thing(tm), and CVS lets us do this. Thus, following
|
||||
some basic rules with regards to CVS usage will:
|
||||
|
||||
a. Make everybody happier, especially those responsible for maintaining
|
||||
the CVS itself.
|
||||
b. Keep the changes consistently well documented and easily trackable.
|
||||
c. Prevent some of those 'Oops' moments.
|
||||
d. Increase the general level of good will on planet Earth.
|
||||
|
||||
|
||||
Having said that, here are the organizational rules:
|
||||
|
||||
1. Respect other people working on the project.
|
||||
|
||||
2. Discuss any significant changes on the list before committing.
|
||||
|
||||
3. Look at EXTENSIONS file to see who is the primary maintainer of
|
||||
the code you want to contribute to.
|
||||
|
||||
4. If you "strongly disagree" about something another person did, don't
|
||||
start fighting publicly - take it up in private email.
|
||||
|
||||
5. If you don't know how to do something, ask first!
|
||||
|
||||
6. Test your changes before committing them. We mean it. Really.
|
||||
|
||||
|
||||
The next few rules are more of a technical nature.
|
||||
|
||||
1. DO NOT TOUCH ChangeLog! It is automagically updated from the commit
|
||||
messages every day. Woe be to those who attempt to mess with it.
|
||||
|
||||
2. All news updates intended for public viewing, such as new features,
|
||||
bug fixes, improvements, etc., should go into the NEWS file. Also see
|
||||
the note below about automatically updating NEWS in your commit message.
|
||||
|
||||
3. Do not commit multiple file and dump all messages in one commit. If you
|
||||
modified several unrelated files, commit each group separately and
|
||||
provide a nice commit message for each one. See example below.
|
||||
|
||||
4. Do write your commit message in such a way that it makes sense even
|
||||
without the corresponding diff. One should be able to look at it, and
|
||||
immediately know what was modified. Definitely include the function name
|
||||
in the message as shown below.
|
||||
|
||||
5. In your commit messages, keep each line shorter than 80 characters. And
|
||||
try to align your lines vertically, if they wrap. It looks bad otherwise.
|
||||
|
||||
6. If you modified a function that is callable from PHP, prepend PHP to
|
||||
the function name as shown below.
|
||||
|
||||
|
||||
The format of the commit messages is pretty simple.
|
||||
|
||||
If a line begins with #, it is taken to be a comment and will not appear
|
||||
in the ChangeLog. If the line begins with @, it will be redirected to the
|
||||
NEWS file. Everything else goes into the ChangeLog.
|
||||
|
||||
It is important to note that if your comment or news logline spans multiple
|
||||
lines, you have to put # or @ at the beginning of _every_ such line. Every
|
||||
entry in NEWS has to have a name after it, so if you did it with someone's
|
||||
help, put both your names there. Your name WILL NOT be automatically put
|
||||
at the end of the NEWS entry - so, please provide it yourself.
|
||||
|
||||
Example. Say you modified two files, datetime.c and string.c. In datetime.c
|
||||
you added a new format option for date() function, and in string.c you fixed
|
||||
a memory leak in php_trim(). Don't commit both of these at once. Commit them
|
||||
separately and try to make sure your commit messages look something like the
|
||||
following.
|
||||
|
||||
For datetime.c:
|
||||
|
||||
(PHP date) Added new 'K' format modifier for printing out number of
|
||||
days until New Year's Eve.
|
||||
@- Added new 'K' format modifier that will output the number of days
|
||||
@ until New Year's Eve. (Bob)
|
||||
|
||||
For string.c:
|
||||
(php_trim) Fixed a memory leak resulting from improper use of zval_dtor().
|
||||
# Man, that thing was leaking all over the place!
|
||||
@- Memory leak in trim() function has finally been fixed. (Bob)
|
||||
|
||||
The lines above marked with @ will go into NEWS file automagically, and the
|
||||
# lines will be omitted from the ChangeLog. Alternatively, you might want
|
||||
to modify NEWS file directly and not use the @ lines.
|
||||
|
||||
If you fix some bugs, you should note the bug ID numbers in your
|
||||
commit message. Bug ID should be prefixed by "#" for easier access to
|
||||
bug report when developers are browsing CVS via. LXR or Bonsai.
|
||||
|
||||
Example:
|
||||
|
||||
Fixed pgsql notice handler double free crash bug. Bug #14016
|
||||
@ Fixed pgsql notice handler double free crash bug. Bug #14016
|
||||
|
||||
If you don't see your messages in ChangeLog and NEWS right away, don't worry!
|
||||
These files are updated once a day, so your stuff will not show up until
|
||||
somewhat later. Don't go adding stuff to NEWS by hand if you already put @
|
||||
lines in the commit message.
|
||||
|
||||
You can use LXR (http://lxr.php.net/) and Bonsai (http://bonsai.php.net/)
|
||||
to look at PHP CVS repository in various ways.
|
||||
|
||||
To receive daily updates to ChangeLog and NEWS, send an empty message to
|
||||
php-cvs-daily-subscribe@lists.php.net.
|
||||
|
||||
Happy hacking,
|
||||
|
||||
PHP Team
|
||||
@@ -1,39 +0,0 @@
|
||||
Between PHP 4.0.6 and 4.1.0, the Zend module struct changed in a way
|
||||
that broke both source and binary compatibility. If you are
|
||||
maintaining a third party extension, here's how to update it:
|
||||
|
||||
If this was your old module entry:
|
||||
|
||||
zend_module_entry foo_module_entry = {
|
||||
"foo", /* extension name */
|
||||
foo_functions, /* extension function list */
|
||||
NULL, /* extension-wide startup function */
|
||||
NULL, /* extension-wide shutdown function */
|
||||
PHP_RINIT(foo), /* per-request startup function */
|
||||
PHP_RSHUTDOWN(foo), /* per-request shutdown function */
|
||||
PHP_MINFO(foo), /* information function */
|
||||
STANDARD_MODULE_PROPERTIES
|
||||
};
|
||||
|
||||
Here's how it should look if you want your code to build with PHP
|
||||
4.1.0 and up:
|
||||
|
||||
zend_module_entry foo_module_entry = {
|
||||
#if ZEND_MODULE_API_NO >= 20010901
|
||||
STANDARD_MODULE_HEADER,
|
||||
#endif
|
||||
"foo", /* extension name */
|
||||
foo_functions, /* extension function list */
|
||||
NULL, /* extension-wide startup function */
|
||||
NULL, /* extension-wide shutdown function */
|
||||
PHP_RINIT(foo), /* per-request startup function */
|
||||
PHP_RSHUTDOWN(foo), /* per-request shutdown function */
|
||||
PHP_MINFO(foo), /* information function */
|
||||
#if ZEND_MODULE_API_NO >= 20010901
|
||||
FOO_VERSION, /* extension version number (string) */
|
||||
#endif
|
||||
STANDARD_MODULE_PROPERTIES
|
||||
};
|
||||
|
||||
If you don't care about source compatibility with earlier PHP releases
|
||||
than 4.1.0, you can drop the #if/#endif lines.
|
||||
-189
@@ -1,189 +0,0 @@
|
||||
|
||||
WHAT IT IS
|
||||
|
||||
It's a tool for automatically creating the basic framework for a PHP module
|
||||
and writing C code handling arguments passed to your functions from a simple
|
||||
configuration file. See an example at the end of this file.
|
||||
|
||||
HOW TO USE IT
|
||||
|
||||
Very simple. First, cd do directory ext/ in PHP 4 sources. If you just need
|
||||
the basic framework and will be writing all the code in your functions
|
||||
yourself, you can now do
|
||||
|
||||
./ext_skel --extname=module_name
|
||||
|
||||
and everything you need is placed in directory module_name.
|
||||
|
||||
[ Note that GNU awk is likely required for this script to work. Debian
|
||||
systems seem to default to using mawk, so you may need to change the
|
||||
#! line in skeleton/create_stubs to use gawk explicitly. ]
|
||||
|
||||
If you don't need to test the existence of any external header files,
|
||||
libraries or functions in them, the module is already almost ready to be
|
||||
compiled in PHP. Just remove 3 comments in your_module_name/config.m4,
|
||||
cd back up to PHP sources top directory, and do
|
||||
|
||||
./buildconf; ./configure --enable-module_name; make
|
||||
|
||||
But if you already have planned the overall scheme of your module, what
|
||||
functions it will contain, their return types and the arguments they take
|
||||
(a very good idea) and don't want to bother yourself with creating function
|
||||
definitions and handling arguments passed yourself, it's time to create a
|
||||
function definitions file, which you will give as an argument to ext_skel
|
||||
with option
|
||||
|
||||
--proto=filename.
|
||||
|
||||
FORMAT OF FUNCTION DEFINITIONS FILE
|
||||
|
||||
All the definitions must be on one line. In it's simplest form, it's just
|
||||
the function name, ie.
|
||||
|
||||
my_function
|
||||
|
||||
but then you'll be left with an almost empty function body without any
|
||||
argument handling.
|
||||
|
||||
Arguments are given in parenthesis after the function name, and are of
|
||||
the form 'argument_type argument_name'. Arguments are separated from each
|
||||
other with a comma and optional space. Argument_type can be one of int,
|
||||
bool, double, float, string, array, object or mixed.
|
||||
|
||||
An optional argument is separated from the previous by an optional space,
|
||||
then '[' and of course comma and optional space, like all the other
|
||||
arguments. You should close a row of optional arguments with same amount of
|
||||
']'s as there where '['s. Currently, it does not harm if you forget to do it
|
||||
or there is a wrong amount of ']'s, but this may change in the future.
|
||||
|
||||
An additional short description may be added after the parameters.
|
||||
If present it will be filled into the 'proto' header comments in the stubs
|
||||
code and the <refpurpose> tag in the XML documentation.
|
||||
|
||||
An example:
|
||||
|
||||
my_function(int arg1, int arg2 [, int arg3 [, int arg4]]) this is my 1st
|
||||
|
||||
Arguments arg3 and arg4 are optional.
|
||||
|
||||
If possible, the function definition should also contain it's return type
|
||||
in front of the definition. It's not actually used for any C code generating
|
||||
purposes but PHP in-source documentation instead, and as such, very useful.
|
||||
It can be any of int, double, string, bool, array, object, resource, mixed
|
||||
or void.
|
||||
|
||||
The file must contain nothing else but function definitions, no comments or
|
||||
empty lines.
|
||||
|
||||
OTHER OPTIONS
|
||||
|
||||
--no-help
|
||||
|
||||
By default, ext_skel creates both comments in the source code and a test
|
||||
function to help first time module writers to get started and testing
|
||||
configuring and compiling their module. This option turns off all such things
|
||||
which may just annoy experienced PHP module coders. Especially useful with
|
||||
|
||||
--stubs=file
|
||||
|
||||
which will leave out also all module specific stuff and write just function
|
||||
stubs with function value declarations and passed argument handling, and
|
||||
function entries and definitions at the end of the file, for copying and
|
||||
pasting into an already existing module.
|
||||
|
||||
--assign-params
|
||||
--string-lens
|
||||
|
||||
By default, function proto 'void foo(string bar)' creates the following:
|
||||
...
|
||||
zval **bar;
|
||||
... (zend_get_parameters_ex() called in the middle...)
|
||||
convert_to_string_ex(bar);
|
||||
|
||||
Specifying both of these options changes the generated code to:
|
||||
...
|
||||
zval **bar_arg;
|
||||
int bar_len;
|
||||
char *bar = NULL;
|
||||
... (zend_get_parameters_ex() called in the middle...)
|
||||
convert_to_string_ex(bar_arg);
|
||||
bar = Z_STRVAL_PP(bar_arg);
|
||||
bar_len = Z_STRLEN_PP(bar_arg);
|
||||
|
||||
You shouldn't have to ask what happens if you leave --string-lens out. If you
|
||||
have to, it's questionable whether you should be reading this document.
|
||||
|
||||
--with-xml[=file]
|
||||
|
||||
Creates the basics for phpdoc .xml file.
|
||||
|
||||
--full-xml
|
||||
|
||||
Not implemented yet. When or if there will ever be created a framework for
|
||||
self-contained extensions to use phpdoc system for their documentation, this
|
||||
option enables it on the created xml file.
|
||||
|
||||
CURRENT LIMITATIONS, BUGS AND OTHER ODDITIES
|
||||
|
||||
Only arguments of types int, bool, double, float, string and array are
|
||||
handled. For other types you must write the code yourself. And for type
|
||||
mixed, it wouldn't even be possible to write anything, because only you
|
||||
know what to expect.
|
||||
|
||||
It can't handle correctly, and probably never will, variable list of
|
||||
of arguments. (void foo(int bar [, ...])
|
||||
|
||||
Don't trust the generated code too much. It tries to be useful in most of
|
||||
the situations you might encounter, but automatic code generation will never
|
||||
beat a programmer who knows the real situation at hand. ext_skel is generally
|
||||
best suited for quickly generating a wrapper for c-library functions you
|
||||
might want to have available in PHP too.
|
||||
|
||||
This program doesn't have a --help option. It has --no-help instead.
|
||||
|
||||
EXAMPLE
|
||||
|
||||
The following _one_ line
|
||||
|
||||
bool my_drawtext(resource image, string text, resource font, int x, int y [, int color])
|
||||
|
||||
will create this function definition for you (note that there are a few
|
||||
question marks to be replaced by you, and you must of course add your own
|
||||
value definitions too):
|
||||
|
||||
/* {{{ proto bool my_drawtext(resource image, string text, resource font, int x, int y[, int color])
|
||||
*/
|
||||
PHP_FUNCTION(my_drawtext)
|
||||
{
|
||||
zval **image, **text, **font, **x, **y, **color;
|
||||
int argc;
|
||||
int image_id = -1;
|
||||
int font_id = -1;
|
||||
|
||||
argc = ZEND_NUM_ARGS();
|
||||
if (argc < 5 || argc > 6 || zend_get_parameters_ex(argc, &image, &text, &font, &x, &y, &color) == FAILURE) {
|
||||
WRONG_PARAM_COUNT;
|
||||
}
|
||||
|
||||
ZEND_FETCH_RESOURCE(???, ???, image, image_id, "???", ???_rsrc_id);
|
||||
ZEND_FETCH_RESOURCE(???, ???, font, font_id, "???", ???_rsrc_id);
|
||||
|
||||
switch (argc) {
|
||||
case 6:
|
||||
convert_to_long_ex(color);
|
||||
/* Fall-through. */
|
||||
case 5:
|
||||
convert_to_long_ex(y);
|
||||
convert_to_long_ex(x);
|
||||
/* font: fetching resources already handled. */
|
||||
convert_to_string_ex(text);
|
||||
/* image: fetching resources already handled. */
|
||||
break;
|
||||
default:
|
||||
WRONG_PARAM_COUNT;
|
||||
}
|
||||
|
||||
php_error(E_WARNING, "my_drawtext: not yet implemented");
|
||||
}
|
||||
/* }}} */
|
||||
|
||||
@@ -1,118 +0,0 @@
|
||||
New parameter parsing functions
|
||||
===============================
|
||||
|
||||
It should be easier to parse input parameters to an extension function.
|
||||
Hence, borrowing from Python's example, there are now a set of functions
|
||||
that given the string of type specifiers, can parse the input parameters
|
||||
and store the results in the user specified variables. This avoids most
|
||||
of the IS_* checks and convert_to_* conversions. The functions also
|
||||
check for the appropriate number of parameters, and try to output
|
||||
meaningful error messages.
|
||||
|
||||
|
||||
Prototypes
|
||||
----------
|
||||
/* Implemented. */
|
||||
int zend_parse_parameters(int num_args TSRMLS_DC, char *type_spec, ...);
|
||||
int zend_parse_parameters_ex(int flags, int num_args TSRMLS_DC, char *type_spec, ...);
|
||||
|
||||
The zend_parse_parameters() function takes the number of parameters
|
||||
passed to the extension function, the type specifier string, and the
|
||||
list of pointers to variables to store the results in. The _ex() version
|
||||
also takes 'flags' argument -- current only ZEND_PARSE_PARAMS_QUIET can
|
||||
be used as 'flags' to specify that the function should operate quietly
|
||||
and not output any error messages.
|
||||
|
||||
Both functions return SUCCESS or FAILURE depending on the result.
|
||||
|
||||
The auto-conversions are performed as necessary. Arrays, objects, and
|
||||
resources cannot be autoconverted.
|
||||
|
||||
|
||||
Type specifiers
|
||||
---------------
|
||||
l - long
|
||||
d - double
|
||||
s - string (with possible null bytes) and its length
|
||||
b - boolean, stored in zend_bool
|
||||
r - resource (stored in zval)
|
||||
a - array
|
||||
o - object (of any type)
|
||||
O - object (of specific type, specified by class entry)
|
||||
z - the actual zval
|
||||
|
||||
The following characters also have a meaning in the specifier string:
|
||||
| - indicates that the remaining parameters are optional, they
|
||||
should be initialized to default values by the extension since they
|
||||
will not be touched by the parsing function if they are not
|
||||
passed to it.
|
||||
/ - use SEPARATE_ZVAL_IF_NOT_REF() on the parameter it follows
|
||||
! - the parameter it follows can be of specified type or NULL (only applies
|
||||
to 'a', 'o', 'O', 'r', and 'z'). If NULL is passed, the results
|
||||
pointer is set to NULL as well.
|
||||
|
||||
Examples
|
||||
--------
|
||||
/* Gets a long, a string and its length, and a zval */
|
||||
long l;
|
||||
char *s;
|
||||
int s_len;
|
||||
zval *param;
|
||||
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "lsz",
|
||||
&l, &s, &s_len, ¶m) == FAILURE) {
|
||||
return;
|
||||
}
|
||||
|
||||
|
||||
/* Gets an object of class specified by my_ce, and an optional double. */
|
||||
zval *obj;
|
||||
double d = 0.5;
|
||||
zend_class_entry my_ce;
|
||||
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "O|d",
|
||||
&obj, my_ce, &d) == FAILURE) {
|
||||
return;
|
||||
}
|
||||
|
||||
|
||||
/* Gets an object or null, and an array.
|
||||
If null is passed for object, obj will be set to NULL. */
|
||||
zval *obj;
|
||||
zval *arr;
|
||||
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "o!a",
|
||||
&obj, &arr) == FAILURE) {
|
||||
return;
|
||||
}
|
||||
|
||||
|
||||
/* Gets a separated array which can also be null. */
|
||||
zval *arr;
|
||||
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a/!",
|
||||
&arr) == FAILURE) {
|
||||
return;
|
||||
}
|
||||
|
||||
|
||||
/* Get only the first three parameters (useful for varargs functions). */
|
||||
zval *z;
|
||||
zend_bool b;
|
||||
zval *r;
|
||||
if (zend_parse_parameters(3 TSRMLS_CC, "zbr!",
|
||||
&z, &b, &r) == FAILURE) {
|
||||
return;
|
||||
}
|
||||
|
||||
|
||||
/* Get either a set of 3 longs or a string. */
|
||||
long l1, l2, l3;
|
||||
char *s;
|
||||
if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, ZEND_NUM_ARGS() TSRMLS_CC,
|
||||
"lll", &l1, &l2, &l3) == SUCCESS) {
|
||||
/* manipulate longs */
|
||||
} else if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, ZEND_NUM_ARGS() TSRMLS_CC,
|
||||
"s", &s) == SUCCESS) {
|
||||
/* manipulate string */
|
||||
} else {
|
||||
/* output error */
|
||||
|
||||
return;
|
||||
}
|
||||
-57
@@ -1,57 +0,0 @@
|
||||
QNX4 Installation Notes
|
||||
-----------------------
|
||||
|
||||
NOTE: General installation instructions are in the INSTALL file
|
||||
|
||||
|
||||
1. To compile and test PHP3 you have to grab, compile and install:
|
||||
- GNU dbm library or another db library;
|
||||
- GNU bison (1.25 or later; 1.25 tested);
|
||||
- GNU flex (any version supporting -o and -P options; 2.5.4 tested);
|
||||
- GNU diffutils (any version supporting -w option; 2.7 tested);
|
||||
|
||||
2. To use CVS version you may need also:
|
||||
- GNU CVS (1.9 tested);
|
||||
- GNU autoconf (2.12 tested);
|
||||
- GNU m4 (1.3 or later preferable; 1.4 tested);
|
||||
|
||||
3. To run configure define -lunix in command line:
|
||||
LDFLAGS=-lunix ./configure
|
||||
|
||||
4. To use Sybase SQL Anywhere define ODBC_QNX and CUSTOM_ODBC_LIBS in
|
||||
command line and run configure with --with-custom-odbc:
|
||||
CFLAGS=-DODBC_QNX LDFLAGS=-lunix CUSTOM_ODBC_LIBS="-ldblib -lodbc" ./configure --with-custom-odbc=/usr/lib/sqlany50
|
||||
If you have SQL Anywhere version 5.5.00, then you have to add
|
||||
CFLAGS=-DSQLANY_BUG
|
||||
to workaround its SQLFreeEnv() bug. Other versions has not been tested,
|
||||
so try without this flag first.
|
||||
|
||||
5. To build the Apache module, you may have to hardcode an include path for
|
||||
alloc.h in your Apache base directory:
|
||||
- APACHE_DIRECTORY/src/httpd.h:
|
||||
change #include "alloc.h"
|
||||
to #include "APACHE_DIRECTORY/src/alloc.h"
|
||||
Unless you want to use system regex library, you have to hardcode also
|
||||
a path to regex.h:
|
||||
- APACHE_DIRECTORY/src/conf.h:
|
||||
change #include <regex.h>
|
||||
to #include "APACHE_DIRECTORY/src/regex/regex.h"
|
||||
I don't know so far why this required for QNX, may be it is Watcom
|
||||
compiler problem.
|
||||
|
||||
If you building Apache module with SQL Anywhere support, you'll get
|
||||
symbol conflict with BOOL. It is defined in Apache (httpd.h) and in
|
||||
SQL Anywhere (odbc.h). This has nothing to do with PHP, so you have to
|
||||
fix it yourself someway.
|
||||
|
||||
6. With above precautions, it should compile as is and pass regression
|
||||
tests completely:
|
||||
make
|
||||
make check
|
||||
make install
|
||||
|
||||
Don't bother me unless you really sure you made that all but it
|
||||
still doesn't work.
|
||||
|
||||
June 28, 1998
|
||||
Igor Kovalenko -- owl@infomarket.ru
|
||||
@@ -1,154 +0,0 @@
|
||||
$Id$
|
||||
=============================================================================
|
||||
|
||||
HOW TO CREATE A SELF-CONTAINED PHP EXTENSION
|
||||
|
||||
A self-contained extension can be distributed independently of
|
||||
the PHP source. To create such an extension, three things are
|
||||
required:
|
||||
|
||||
- Configuration file (config.m4)
|
||||
- Source code for your module
|
||||
|
||||
We will describe now how to create these and how to put things
|
||||
together.
|
||||
|
||||
PREPARING YOUR SYSTEM
|
||||
|
||||
While the result will run on any system, a developer's setup needs these
|
||||
tools:
|
||||
|
||||
GNU autoconf
|
||||
GNU automake
|
||||
GNU libtool
|
||||
GNU m4
|
||||
|
||||
All of these are available from
|
||||
|
||||
ftp://ftp.gnu.org/pub/gnu/
|
||||
|
||||
CONVERTING AN EXISTING EXTENSION
|
||||
|
||||
Just to show you how easy it is to create a self-contained
|
||||
extension, we will convert an embedded extension into a
|
||||
self-contained one. Install PHP and execute the following
|
||||
commands.
|
||||
|
||||
$ mkdir /tmp/newext
|
||||
$ cd /tmp/newext
|
||||
|
||||
You now have an empty directory. We will copy the files from
|
||||
the mysql extension:
|
||||
|
||||
$ cp -rp php-4.0.X/ext/mysql/* .
|
||||
|
||||
It is time to finish the module. Run:
|
||||
|
||||
$ phpize
|
||||
|
||||
You can now ship the contents of the directory - the extension
|
||||
can live completely on its own.
|
||||
|
||||
The user instructions boil down to
|
||||
|
||||
$ ./configure \
|
||||
[--with-php-config=/path/to/php-config] \
|
||||
[--with-mysql=MYSQL-DIR]
|
||||
$ make install
|
||||
|
||||
The MySQL module will either use the embedded MySQL client
|
||||
library or the MySQL installation in MYSQL-DIR.
|
||||
|
||||
|
||||
DEFINING THE NEW EXTENSION
|
||||
|
||||
Our demo extension is called "foobar".
|
||||
|
||||
It consists of two source files "foo.c" and "bar.c"
|
||||
(and any arbitrary amount of header files, but that is not
|
||||
important here).
|
||||
|
||||
The demo extension does not reference any external
|
||||
libraries (that is important, because the user does not
|
||||
need to specify anything).
|
||||
|
||||
|
||||
LTLIBRARY_SOURCES specifies the names of the sources files. You can
|
||||
name an arbitrary number of source files here.
|
||||
|
||||
CREATING THE M4 CONFIGURATION FILE
|
||||
|
||||
The m4 configuration can perform additional checks. For a
|
||||
self-contained extension, you do not need more than a few
|
||||
macro calls.
|
||||
|
||||
------------------------------------------------------------------------------
|
||||
PHP_ARG_ENABLE(foobar,whether to enable foobar,
|
||||
[ --enable-foobar Enable foobar])
|
||||
|
||||
if test "$PHP_FOOBAR" != "no"; then
|
||||
PHP_NEW_EXTENSION(foobar, foo.c bar.c, $ext_shared)
|
||||
fi
|
||||
------------------------------------------------------------------------------
|
||||
|
||||
PHP_ARG_ENABLE will automatically set the correct variables, so
|
||||
that the extension will be enabled by PHP_NEW_EXTENSION in shared mode.
|
||||
|
||||
The first argument of PHP_NEW_EXTENSION describes the name of the
|
||||
extension. The second names the source-code files. The third passes
|
||||
$ext_shared which is set by PHP_ARG_ENABLE/WITH to PHP_NEW_EXTENSION.
|
||||
|
||||
Please use always PHP_ARG_ENABLE or PHP_ARG_WITH. Even if you do not
|
||||
plan to distribute your module with PHP, these facilities allow you
|
||||
to integrate your module easily into the main PHP module framework.
|
||||
|
||||
CREATING SOURCE FILES
|
||||
|
||||
ext_skel can be of great help when creating the common code for all modules
|
||||
in PHP for you and also writing basic function definitions and C code for
|
||||
handling arguments passed to your functions. See README.EXT_SKEL for further
|
||||
information.
|
||||
|
||||
As for the rest, you are currently alone here. There are a lot of existing
|
||||
modules, use a simple module as a starting point and add your own code.
|
||||
|
||||
|
||||
CREATING THE SELF-CONTAINED EXTENSION
|
||||
|
||||
Put config.m4 and the source files into one directory. Afterwards,
|
||||
run phpize (this is installed during make install by PHP 4.0).
|
||||
For example, if you configured PHP with --prefix=/php, you would run
|
||||
|
||||
$ /php/bin/phpize
|
||||
|
||||
This will automatically copy the necessary build files and create
|
||||
configure from your config.m4.
|
||||
|
||||
And that's it. You now have a self-contained extension.
|
||||
|
||||
INSTALLING A SELF-CONTAINED EXTENSION
|
||||
|
||||
An extension can be installed by running:
|
||||
|
||||
$ ./configure \
|
||||
[--with-php-config=/path/to/php-config]
|
||||
$ make install
|
||||
|
||||
ADDING SHARED MODULE SUPPORT TO A MODULE
|
||||
|
||||
In order to be useful, a self-contained extension must be loadable
|
||||
as a shared module. I will explain now how you can add shared module
|
||||
support to an existing module called foo.
|
||||
|
||||
1. In config.m4, use PHP_ARG_WITH/PHP_ARG_ENABLE. Then you will
|
||||
automatically be able to use --with-foo=shared[,..] or
|
||||
--enable-foo=shared[,..].
|
||||
|
||||
2. In config.m4, use PHP_NEW_EXTENSION(foo,.., $ext_shared) to enable
|
||||
building the extension.
|
||||
|
||||
3. Add the following lines to your C source file:
|
||||
|
||||
#ifdef COMPILE_DL_FOO
|
||||
ZEND_GET_MODULE(foo)
|
||||
#endif
|
||||
-367
@@ -1,367 +0,0 @@
|
||||
An Overview of the PHP Streams abstraction
|
||||
==========================================
|
||||
$Id$
|
||||
|
||||
Please send comments to: Wez Furlong <wez@thebrainroom.com>
|
||||
|
||||
Why Streams?
|
||||
============
|
||||
You may have noticed a shed-load of issock parameters flying around the PHP
|
||||
code; we don't want them - they are ugly and cumbersome and force you to
|
||||
special case sockets and files everytime you need to work with a "user-level"
|
||||
PHP file pointer.
|
||||
Streams take care of that and present the PHP extension coder with an ANSI
|
||||
stdio-alike API that looks much nicer and can be extended to support non file
|
||||
based data sources.
|
||||
|
||||
Using Streams
|
||||
=============
|
||||
Streams use a php_stream* parameter just as ANSI stdio (fread etc.) use a
|
||||
FILE* parameter.
|
||||
|
||||
The main functions are:
|
||||
|
||||
PHPAPI size_t php_stream_read(php_stream * stream, char * buf, size_t count);
|
||||
PHPAPI size_t php_stream_write(php_stream * stream, const char * buf, size_t
|
||||
count);
|
||||
PHPAPI int php_stream_eof(php_stream * stream);
|
||||
PHPAPI int php_stream_getc(php_stream * stream);
|
||||
PHPAPI char *php_stream_gets(php_stream * stream, char *buf, size_t maxlen);
|
||||
PHPAPI int php_stream_close(php_stream * stream);
|
||||
PHPAPI int php_stream_flush(php_stream * stream);
|
||||
PHPAPI int php_stream_seek(php_stream * stream, off_t offset, int whence);
|
||||
PHPAPI off_t php_stream_tell(php_stream * stream);
|
||||
|
||||
These (should) behave in the same way as the ANSI stdio functions with similar
|
||||
names: fread, fwrite, feof, fgetc, fgets, fclose, fflush, fseek, ftell.
|
||||
|
||||
Opening Streams
|
||||
===============
|
||||
In most cases, you should use this API:
|
||||
|
||||
PHPAPI php_stream *php_stream_open_wrapper(char *path, char *mode,
|
||||
int options, char **opened_path TSRMLS_DC);
|
||||
|
||||
Where:
|
||||
path is the file or resource to open.
|
||||
mode is the stdio compatible mode eg: "wb", "rb" etc.
|
||||
options is a combination of the following values:
|
||||
IGNORE_PATH (default) - don't use include path to search for the file
|
||||
USE_PATH - use include path to search for the file
|
||||
IGNORE_URL - do not use plugin wrappers
|
||||
REPORT_ERRORS - show errors in a standard format if something
|
||||
goes wrong.
|
||||
STREAM_MUST_SEEK - If you really need to be able to seek the stream
|
||||
and don't need to be able to write to the original
|
||||
file/URL, use this option to arrange for the stream
|
||||
to be copied (if needed) into a stream that can
|
||||
be seek()ed.
|
||||
|
||||
opened_path is used to return the path of the actual file opened,
|
||||
but if you used STREAM_MUST_SEEK, may not be valid. You are
|
||||
responsible for efree()ing opened_path. opened_path may be (and usually
|
||||
is) NULL.
|
||||
|
||||
If you need to open a specific stream, or convert standard resources into
|
||||
streams there are a range of functions to do this defined in php_streams.h.
|
||||
A brief list of the most commonly used functions:
|
||||
|
||||
PHPAPI php_stream *php_stream_fopen_from_file(FILE *file, const char *mode);
|
||||
Convert a FILE * into a stream.
|
||||
|
||||
PHPAPI php_stream *php_stream_fopen_tmpfile(void);
|
||||
Open a FILE * with tmpfile() and convert into a stream.
|
||||
|
||||
PHPAPI php_stream *php_stream_fopen_temporary_file(const char *dir,
|
||||
const char *pfx, char **opened_path TSRMLS_DC);
|
||||
Generate a temporary file name and open it.
|
||||
|
||||
There are some network enabled relatives in php_network.h:
|
||||
|
||||
PHPAPI php_stream *php_stream_sock_open_from_socket(int socket, int persistent);
|
||||
Convert a socket into a stream.
|
||||
|
||||
PHPAPI php_stream *php_stream_sock_open_host(const char *host, unsigned short port,
|
||||
int socktype, int timeout, int persistent);
|
||||
Open a connection to a host and return a stream.
|
||||
|
||||
PHPAPI php_stream *php_stream_sock_open_unix(const char *path, int persistent,
|
||||
struct timeval *timeout);
|
||||
Open a UNIX domain socket.
|
||||
|
||||
|
||||
Stream Utilities
|
||||
================
|
||||
|
||||
If you need to copy some data from one stream to another, you will be please
|
||||
to know that the streams API provides a standard way to do this:
|
||||
|
||||
PHPAPI size_t php_stream_copy_to_stream(php_stream *src,
|
||||
php_stream *dest, size_t maxlen);
|
||||
|
||||
If you want to copy all remaining data from the src stream, pass
|
||||
PHP_STREAM_COPY_ALL as the maxlen parameter, otherwise maxlen indicates the
|
||||
number of bytes to copy.
|
||||
This function will try to use mmap where available to make the copying more
|
||||
efficient.
|
||||
|
||||
If you want to read the contents of a stream into an allocated memory buffer,
|
||||
you should use:
|
||||
|
||||
PHPAPI size_t php_stream_copy_to_mem(php_stream *src, char **buf,
|
||||
size_t maxlen, int persistent);
|
||||
|
||||
This function will set buf to the address of the buffer that it allocated,
|
||||
which will be maxlen bytes in length, or will be the entire length of the
|
||||
data remaining on the stream if you set maxlen to PHP_STREAM_COPY_ALL.
|
||||
The buffer is allocated using pemalloc(); you need to call pefree() to
|
||||
release the memory when you are done.
|
||||
As with copy_to_stream, this function will try use mmap where it can.
|
||||
|
||||
If you have an existing stream and need to be able to seek() it, you
|
||||
can use this function to copy the contents into a new stream that can
|
||||
be seek()ed:
|
||||
|
||||
PHPAPI int php_stream_make_seekable(php_stream *origstream, php_stream **newstream);
|
||||
|
||||
It returns one of the following values:
|
||||
#define PHP_STREAM_UNCHANGED 0 /* orig stream was seekable anyway */
|
||||
#define PHP_STREAM_RELEASED 1 /* newstream should be used; origstream is no longer valid */
|
||||
#define PHP_STREAM_FAILED 2 /* an error occurred while attempting conversion */
|
||||
#define PHP_STREAM_CRITICAL 3 /* an error occurred; origstream is in an unknown state; you should close origstream */
|
||||
|
||||
make_seekable will always set newstream to be the stream that is valid
|
||||
if the function succeeds.
|
||||
When you have finished, remember to close the stream.
|
||||
|
||||
NOTE: If you only need to seek forwards, there is no need to call this
|
||||
function, as the php_stream_seek can emulate forward seeking when the
|
||||
whence parameter is SEEK_CUR.
|
||||
|
||||
NOTE: Writing to the stream may not affect the original source, so it
|
||||
only makes sense to use this for read-only use.
|
||||
|
||||
NOTE: If the origstream is network based, this function will block
|
||||
until the whole contents have been downloaded.
|
||||
|
||||
NOTE: Never call this function with an origstream that is referenced
|
||||
as a resource! It will close the origstream on success, and this
|
||||
can lead to a crash when the resource is later used/released.
|
||||
|
||||
NOTE: If you are opening a stream and need it to be seekable, use the
|
||||
STREAM_MUST_SEEK option to php_stream_open_wrapper();
|
||||
|
||||
Casting Streams
|
||||
===============
|
||||
What if your extension needs to access the FILE* of a user level file pointer?
|
||||
You need to "cast" the stream into a FILE*, and this is how you do it:
|
||||
|
||||
FILE * fp;
|
||||
php_stream * stream; /* already opened */
|
||||
|
||||
if (php_stream_cast(stream, PHP_STREAM_AS_STDIO, (void*)&fp, REPORT_ERRORS) == FAILURE) {
|
||||
RETURN_FALSE;
|
||||
}
|
||||
|
||||
The prototype is:
|
||||
|
||||
PHPAPI int php_stream_cast(php_stream * stream, int castas, void ** ret, int
|
||||
show_err);
|
||||
|
||||
The show_err parameter, if non-zero, will cause the function to display an
|
||||
appropriate error message of type E_WARNING if the cast fails.
|
||||
|
||||
castas can be one of the following values:
|
||||
PHP_STREAM_AS_STDIO - a stdio FILE*
|
||||
PHP_STREAM_AS_FD - a generic file descriptor
|
||||
PHP_STREAM_AS_SOCKETD - a socket descriptor
|
||||
|
||||
If you ask a socket stream for a FILE*, the abstraction will use fdopen to
|
||||
create it for you. Be warned that doing so may cause buffered data to be lost
|
||||
if you mix ANSI stdio calls on the FILE* with php stream calls on the stream.
|
||||
|
||||
If your system has the fopencookie function, php streams can synthesize a
|
||||
FILE* on top of any stream, which is useful for SSL sockets, memory based
|
||||
streams, data base streams etc. etc.
|
||||
|
||||
In situations where this is not desireable, you should query the stream
|
||||
to see if it naturally supports FILE *. You can use this code snippet
|
||||
for this purpose:
|
||||
|
||||
if (php_stream_is(stream, PHP_STREAM_IS_STDIO)) {
|
||||
/* can safely cast to FILE* with no adverse side effects */
|
||||
}
|
||||
|
||||
You can use:
|
||||
|
||||
PHPAPI int php_stream_can_cast(php_stream * stream, int castas)
|
||||
|
||||
to find out if a stream can be cast, without actually performing the cast, so
|
||||
to check if a stream is a socket you might use:
|
||||
|
||||
if (php_stream_can_cast(stream, PHP_STREAM_AS_SOCKETD) == SUCCESS) {
|
||||
/* it can be a socket */
|
||||
}
|
||||
|
||||
Please note the difference between php_stream_is and php_stream_can_cast;
|
||||
stream_is tells you if the stream is a particular type of stream, whereas
|
||||
can_cast tells you if the stream can be forced into the form you request.
|
||||
The former doesn't change anything, while the later *might* change some
|
||||
state in the stream.
|
||||
|
||||
Stream Internals
|
||||
================
|
||||
|
||||
There are two main structures associated with a stream - the php_stream
|
||||
itself, which holds some state information (and possibly a buffer) and a
|
||||
php_stream_ops structure, which holds the "virtual method table" for the
|
||||
underlying implementation.
|
||||
|
||||
The php_streams ops struct consists of pointers to methods that implement
|
||||
read, write, close, flush, seek, gets and cast operations. Of these, an
|
||||
implementation need only implement write, read, close and flush. The gets
|
||||
method is intended to be used for streams if there is an underlying method
|
||||
that can efficiently behave as fgets. The ops struct also contains a label
|
||||
for the implementation that will be used when printing error messages - the
|
||||
stdio implementation has a label of "STDIO" for example.
|
||||
|
||||
The idea is that a stream implementation defines a php_stream_ops struct, and
|
||||
associates it with a php_stream using php_stream_alloc.
|
||||
|
||||
As an example, the php_stream_fopen() function looks like this:
|
||||
|
||||
PHPAPI php_stream * php_stream_fopen(const char * filename, const char * mode)
|
||||
{
|
||||
FILE * fp = fopen(filename, mode);
|
||||
php_stream * ret;
|
||||
|
||||
if (fp) {
|
||||
ret = php_stream_alloc(&php_stream_stdio_ops, fp, 0, 0, mode);
|
||||
if (ret)
|
||||
return ret;
|
||||
|
||||
fclose(fp);
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
php_stream_stdio_ops is a php_stream_ops structure that can be used to handle
|
||||
FILE* based streams.
|
||||
|
||||
A socket based stream would use code similar to that above to create a stream
|
||||
to be passed back to fopen_wrapper (or it's yet to be implemented successor).
|
||||
|
||||
The prototype for php_stream_alloc is this:
|
||||
|
||||
PHPAPI php_stream * php_stream_alloc(php_stream_ops * ops, void * abstract,
|
||||
size_t bufsize, int persistent, const char * mode)
|
||||
|
||||
ops is a pointer to the implementation,
|
||||
abstract holds implementation specific data that is relevant to this instance
|
||||
of the stream,
|
||||
bufsize is the size of the buffer to use - if 0, then buffering at the stream
|
||||
level will be disabled (recommended for underlying sources that implement
|
||||
their own buffering - such a FILE*),
|
||||
persistent controls how the memory is to be allocated - persistently so that
|
||||
it lasts across requests, or non-persistently so that it is freed at the end
|
||||
of a request (it uses pemalloc),
|
||||
mode is the stdio-like mode of operation - php streams places no real meaning
|
||||
in the mode parameter, except that it checks for a 'w' in the string when
|
||||
attempting to write (this may change).
|
||||
|
||||
The mode parameter is passed on to fdopen/fopencookie when the stream is cast
|
||||
into a FILE*, so it should be compatible with the mode parameter of fopen().
|
||||
|
||||
Writing your own stream implementation
|
||||
======================================
|
||||
|
||||
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
|
||||
RULE #1: when writing your own streams: make sure you have configured PHP with
|
||||
--enable-debug.
|
||||
I've taken some great pains to hook into the zend memory manager to help track
|
||||
down allocation problems. It will also help you spot incorrect use of the
|
||||
STREAMS_DC, STREAMS_CC and the semi-private STREAMS_REL_CC macros for function
|
||||
definitions.
|
||||
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
|
||||
|
||||
RULE #2: Please use the stdio stream as a reference; it will help you
|
||||
understand the semantics of the stream operations, and it will always
|
||||
be more up to date than these docs :-)
|
||||
|
||||
First, you need to figure out what data you need to associate with the
|
||||
php_stream. For example, you might need a pointer to some memory for memory
|
||||
based streams, or if you were making a stream to read data from an RDBMS like
|
||||
mysql, you might want to store the connection and rowset handles.
|
||||
|
||||
The stream has a field called abstract that you can use to hold this data.
|
||||
If you need to store more than a single field of data, define a structure to
|
||||
hold it, allocate it (use pemalloc with the persistent flag set
|
||||
appropriately), and use the abstract pointer to refer to it.
|
||||
|
||||
For structured state you might have this:
|
||||
|
||||
struct my_state {
|
||||
MYSQL conn;
|
||||
MYSQL_RES * result;
|
||||
};
|
||||
|
||||
struct my_state * state = pemalloc(sizeof(struct my_state), persistent);
|
||||
|
||||
/* initialize the connection, and run a query, using the fields in state to
|
||||
* hold the results */
|
||||
|
||||
state->result = mysql_use_result(&state->conn);
|
||||
|
||||
/* now allocate the stream itself */
|
||||
stream = php_stream_alloc(&my_ops, state, 0, persistent, "r");
|
||||
|
||||
/* now stream->abstract == state */
|
||||
|
||||
Once you have that part figured out, you can write your implementation and
|
||||
define the your own php_stream_ops struct (we called it my_ops in the above
|
||||
example).
|
||||
|
||||
For example, for reading from this wierd mysql stream:
|
||||
|
||||
static size_t php_mysqlop_read(php_stream * stream, char * buf, size_t count)
|
||||
{
|
||||
struct my_state * state = (struct my_state*)stream->abstract;
|
||||
|
||||
if (buf == NULL && count == 0) {
|
||||
/* in this special case, php_streams is asking if we have reached the
|
||||
* end of file */
|
||||
if (... at end of file ...)
|
||||
return EOF;
|
||||
else
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* pull out some data from the stream and put it in buf */
|
||||
... mysql_fetch_row(state->result) ...
|
||||
/* we could do something strange, like format the data as XML here,
|
||||
and place that in the buf, but that brings in some complexities,
|
||||
such as coping with a buffer size too small to hold the data,
|
||||
so I won't even go in to how to do that here */
|
||||
}
|
||||
|
||||
Implement the other operations - remember that write, read, close and flush
|
||||
are all mandatory. The rest are optional. Declare your stream ops struct:
|
||||
|
||||
php_stream_ops my_ops = {
|
||||
php_mysqlop_write, php_mysqlop_read, php_mysqlop_close,
|
||||
php_mysqlop_flush, NULL, NULL, NULL,
|
||||
"Strange mySQL example"
|
||||
}
|
||||
|
||||
Thats it!
|
||||
|
||||
Take a look at the STDIO implementation in streams.c for more information
|
||||
about how these operations work.
|
||||
The main thing to remember is that in your close operation you need to release
|
||||
and free the resources you allocated for the abstract field. In the case of
|
||||
the example above, you need to use mysql_free_result on the rowset, close the
|
||||
connection and then use pefree to dispose of the struct you allocated.
|
||||
You may read the stream->persistent field to determine if your struct was
|
||||
allocated in persistent mode or not.
|
||||
|
||||
vim:tw=78:et
|
||||
@@ -1,121 +0,0 @@
|
||||
Submitting Patch for PHP
|
||||
========================
|
||||
|
||||
This document describes how to submit a patch for PHP. Since you are
|
||||
reading this document, you are willing to submit a patch for PHP.
|
||||
Please keep reading! Submitting a patch for PHP is easy. The hard
|
||||
part is making it acceptable for inclusion into our repository. :-)
|
||||
|
||||
How to create patch?
|
||||
--------------------
|
||||
We are working with CVS. You need to get CVS source to create a patch
|
||||
that we accept. Visit http://www.php.net/anoncvs.php to get CVS
|
||||
source. You can check out older versions, but make sure you get
|
||||
the default branch (i.e. Do not use -r option when you check out the
|
||||
CVS source)
|
||||
|
||||
Read CODING_STANDARDS file before you start working.
|
||||
|
||||
Now you are ready to create a patch. Modify source to fix a bug in PHP or
|
||||
add a new feature to PHP. After you finished editing, please test your
|
||||
patch. Read README.TESTING for testing.
|
||||
|
||||
After you finish testing your patch, take diff file using
|
||||
"cvs diff > your.patch" command.
|
||||
|
||||
Read README.TESTING for submitting a test script for your patch. This is
|
||||
not strictly required, but it is preferred to submit a test script along
|
||||
with your patch. Making new test script is very easy. It also helps us
|
||||
to understand what you have been fixed or added to PHP.
|
||||
|
||||
|
||||
Tips for creating patch
|
||||
-----------------------
|
||||
If you would like to fix multiple bugs. It is easier for us if you
|
||||
could create 1 patch for 1 bug, but this is not strictly required.
|
||||
Note though that you might get little response, if your patch is
|
||||
too hard to review.
|
||||
|
||||
If you would like change/add many lines, it is better to ask module
|
||||
maintainer and/or php-dev@lists.php.net, or pear-dev@lists.php.net if
|
||||
you are patching PEAR. Official module maintainers can be found in
|
||||
EXTENSIONS file in PHP source.
|
||||
|
||||
If you are new to CVS (Concurrent Versions System), visit
|
||||
http://cvshome.org/ for details.
|
||||
|
||||
|
||||
Recommended CVS client settings for creating patch file
|
||||
------------------------------------------------------
|
||||
Recommended ~/.cvsrc file setting is:
|
||||
------
|
||||
cvs -z3
|
||||
update -d -P
|
||||
checkout -P
|
||||
diff -u
|
||||
|
||||
------
|
||||
diff -u means:
|
||||
-u Use the unified output format.
|
||||
|
||||
With this CVS setting, you don't have to worry about adding/deleting
|
||||
newlines and spaces.
|
||||
|
||||
|
||||
Check list for submitting patch
|
||||
-------------------------------
|
||||
- Did you run "make test" to check if your patch didn't break
|
||||
other features?
|
||||
- Did you compile PHP with --enable-debug and check php/webserver
|
||||
error logs when you test your patch?
|
||||
- Did you build PHP for multi-threaded web servers. (Optional)
|
||||
- Did you create test script for "make test"? (Recommended)
|
||||
- Did you check your patch is unified format and it does not
|
||||
contain white space changes? (If you are not using recommended
|
||||
cvs setting)
|
||||
- Did you update CVS source before you take final patch?
|
||||
- Did you read the patch again?
|
||||
|
||||
|
||||
Where to send your patch?
|
||||
-------------------------
|
||||
If you are patching C source, send the patch to php-dev@lists.php.net.
|
||||
If you are patching a module, you should also send the patch to the
|
||||
maintainer. Official module maintainers are listed in EXTENSION file
|
||||
in source.
|
||||
|
||||
If you are patching PEAR, send the patch to pear-dev@lists.php.net.
|
||||
|
||||
Please add the prefix "[PATCH]" to your email subject and make sure
|
||||
to include the patch as a MIME attachment even if it is short.
|
||||
Test scripts should be included in the same email.
|
||||
Explain what has been fixed/added/changed by your patch.
|
||||
|
||||
Finally, add the bug Id(s) which can be closed by your patch, if any.
|
||||
|
||||
|
||||
What happens after you submit your patch
|
||||
--------------------------------------
|
||||
If your patch is easy to review and has obviously no side-effects,
|
||||
it might take up to a few hours until someone commits it.
|
||||
|
||||
Because this is a volunteer-driven effort, more complex patches will
|
||||
require more patience on your side.
|
||||
|
||||
If you did not receive any feedback in a few days, please consider
|
||||
resubmitting the description of your patch, along-side with
|
||||
these questions:
|
||||
|
||||
- Is my patch too hard to review? Because of which factors?
|
||||
- Should I split it up in multiple parts?
|
||||
- Are there any unwanted whitespace changes?
|
||||
|
||||
|
||||
What happens when your patch is applied?
|
||||
----------------------------------------
|
||||
Your name will be included together with your email address in the CVS
|
||||
commit log. If your patch affects end-users, a brief description
|
||||
and your name might be added to the NEWS file.
|
||||
|
||||
|
||||
Thank you for submitting patch for PHP!
|
||||
-175
@@ -1,175 +0,0 @@
|
||||
[IMPORTANT NOTICE]
|
||||
------------------
|
||||
Do _not_ ask to developers why some or all tests are failed under
|
||||
your environment! Let us know if you find why it fails. Thank you.
|
||||
|
||||
|
||||
[Testing Basics]
|
||||
----------------
|
||||
To execute test scripts, you must build PHP with some SAPI, then you
|
||||
type "make test" to execute all or some test scripts saved under
|
||||
"tests" directory under source root directory.
|
||||
|
||||
Usage:
|
||||
make test
|
||||
|
||||
"make test" basically executes "run-tests.php" script
|
||||
under source root. Therefore you can execute the script
|
||||
as follows
|
||||
|
||||
./sapi/cli/php -c /path/to/php.ini/ run-tests.php [ext/some_extension_name]
|
||||
|
||||
|
||||
|
||||
[Which "php" executable "make test" look for]
|
||||
---------------------------------------------
|
||||
"make test" executes "run-tests.php" script with "php" binary. Some
|
||||
test scripts such as session must be executed by CGI SAPI. Therefore,
|
||||
you must build PHP with CGI SAPI to perform all tests.
|
||||
|
||||
If PHP is not build with CGI SAPI, "run-tests.php" script uses CLI
|
||||
SAPI. Tests that may not executed by CLI SAPI will be skipped.
|
||||
|
||||
NOTE: PHP binary executing "run-tests.php" and php binary used for
|
||||
executing test scripts may differ. If you use different PHP binary for
|
||||
executing "run-tests.php" script, you may get errors.
|
||||
|
||||
|
||||
[Which php.ini is used]
|
||||
-----------------------
|
||||
"make test" force to use php.ini-dist as default config file. If
|
||||
you would like to test with other configuration file, user
|
||||
"run-tests.php" script.
|
||||
|
||||
Example:
|
||||
./sapi/cli/php -c /path/to/php.ini/ ext/standard
|
||||
|
||||
If you use php.ini other than php.ini-dist, you may see more failed
|
||||
tests.
|
||||
|
||||
|
||||
[Which test scripts are executed]
|
||||
---------------------------------
|
||||
"run-tests.php" ("make test") executes all test scripts by default
|
||||
by looking all directory named "tests". If there are files have "phpt"
|
||||
extension, "run-tests.php" takes test php code from the file and
|
||||
executes it.
|
||||
|
||||
Tester can easily executes tests selectively with as follows.
|
||||
|
||||
Example:
|
||||
./sapi/cli/php -c /path/to/php.ini/ run-tests.php ext/mbstring
|
||||
|
||||
|
||||
[Test results]
|
||||
--------------
|
||||
Test results are printed to standard output. If there is a failed test,
|
||||
"run-tests.php" script saves the result, expected result and code
|
||||
executed to the test script directory. For example, if
|
||||
ext/myext/tests/myext.phpt is failed to pass, following files are
|
||||
created:
|
||||
|
||||
ext/myext/tests/myext.out - output from test script
|
||||
ext/myext/tests/myext.exp - expected output
|
||||
ext/myext/tests/myext.php - test script executed
|
||||
|
||||
Tester can verify these files, if failed test is actually a bug
|
||||
or not.
|
||||
|
||||
|
||||
[Creating new test files]
|
||||
-------------------------
|
||||
Writing test file is very easy if you are used to PHP. Test file
|
||||
has following format. Here is a actual test file from iconv module.
|
||||
|
||||
===== ext/iconv/002.phpt =======
|
||||
--TEST--
|
||||
UCS4BE to ASCII
|
||||
--SKIPIF--
|
||||
<?php include('skipif.inc'); ?>
|
||||
--POST--
|
||||
--GET--
|
||||
--FILE--
|
||||
<?php include('002.inc'); ?>
|
||||
--EXPECT--
|
||||
abcd
|
||||
abcd
|
||||
===== end of ext/iconv/002.phpt =======
|
||||
|
||||
"--TEST--" is title of the test.
|
||||
"--SKIPIF--" is condition when to skip this test.
|
||||
"--POST--" is POST variable passed to test script.
|
||||
"--GET--" is GET variable passed to test script.
|
||||
"--FILE--" is the test script.
|
||||
"--EXPECT--" is the expected output from the test script.
|
||||
|
||||
ext/iconv/002.phpt uses 2 files. "skipif.inc" is used to skip
|
||||
test when test cannot be performed such as iconv module is not
|
||||
compiled or loaded.
|
||||
|
||||
==== ext/iconv/skipif.inc ====
|
||||
<?php
|
||||
// This script prints "skip" if condition does not meet.
|
||||
|
||||
if (!extension_loaded("iconv") && ini_get("enable_dl")) {
|
||||
$dlext = (substr(PHP_OS, 0, 3) == "WIN") ? ".dll" : ".so";
|
||||
@dl("iconv$dlext");
|
||||
}
|
||||
if (!extension_loaded("iconv")) {
|
||||
die("skip\n");
|
||||
}
|
||||
?>
|
||||
==== end of ext/iconv/skipif.inc ====
|
||||
|
||||
ext/inconv/002.inc is the test script. "run-tests.php" script
|
||||
executes test script with CGI executable.
|
||||
|
||||
==== ext/iconv/002.inc ===
|
||||
<?php
|
||||
/*
|
||||
Expected output:
|
||||
abcd
|
||||
abcd
|
||||
*/
|
||||
|
||||
$s = unpack("V*", iconv("ascii","UCS-4LE", "abcd"));
|
||||
foreach($s as $c) { print "&#$c;"; } print "\n";
|
||||
|
||||
$s = pack("NNNN", 97, 98, 99, 100);
|
||||
$q = iconv("UCS-4BE", "ascii", $s);
|
||||
print $q; print "\n";
|
||||
?>
|
||||
=== end of ext/iconv/002.inc ===
|
||||
|
||||
Test script and skipif code may be directly write into *.phpt.
|
||||
However, it is recommended to use other files for ease of writing
|
||||
test script. For instance, you can execute test script under
|
||||
ext/iconv as follows:
|
||||
|
||||
./sapi/cli/php -c /path/to/php.ini/ ext/iconv
|
||||
|
||||
|
||||
[How to help us]
|
||||
----------------
|
||||
If you find bug in PHP, you can submit bug report AND test script
|
||||
for us. You don't have to write complete script, just give us test
|
||||
script with following format. Please test the script and make sure
|
||||
you write the correct ACTUAL OUTPUT and EXPECTED OUTPUT before you
|
||||
submit.
|
||||
|
||||
<?php
|
||||
/*
|
||||
Bug #12345
|
||||
substr() bug. Do not return expected string.
|
||||
|
||||
ACTUAL OUTPUT
|
||||
XYXA
|
||||
|
||||
EXPECTED OUTPUT
|
||||
ABCD
|
||||
*/
|
||||
|
||||
$str = "XYZABCD";
|
||||
echo substr($str,3,7);
|
||||
|
||||
?>
|
||||
@@ -1,123 +0,0 @@
|
||||
PHP Build System V5 Overview
|
||||
|
||||
- supports Makefile.ins during transition phase
|
||||
- not-really-portable Makefile includes have been eliminated
|
||||
- supports seperate build directories without VPATH by using
|
||||
explicit rules only
|
||||
- does not waste disk-space/CPU-time for building temporary libraries
|
||||
=> especially noticeable on slower systems
|
||||
- slow recursive make replaced with one global Makefile
|
||||
- eases integration of proper dependencies
|
||||
- adds PHP_DEFINE(what[, value]) which creates a single include-file
|
||||
per what. This will allow more fine-grained dependencies.
|
||||
- abandoning the "one library per directory" concept
|
||||
- improved integration of the CLI
|
||||
- several new targets
|
||||
build-modules: builds and copies dynamic modules into modules/
|
||||
install-cli: installs the CLI only, so that the install-sapi
|
||||
target does only what its name says
|
||||
- finally abandoned automake (still requires aclocal at this time)
|
||||
- changed some configure-time constructs to run at buildconf-time
|
||||
- upgraded shtool to 1.5.4
|
||||
- removed $(moduledir) (use EXTENSION_DIR)
|
||||
|
||||
The Reason For a New System
|
||||
|
||||
It became more and more apparent that there is a severe need
|
||||
for addressing the portability concerns and improving the chance
|
||||
that your build is correct (how often have you been told to
|
||||
"make clean"? When this is done, you won't need to anymore).
|
||||
|
||||
|
||||
If You Build PHP on a Unix System
|
||||
|
||||
|
||||
You, as a user of PHP, will notice no changes. Of course, the build
|
||||
system will be faster, look better and work smarter.
|
||||
|
||||
|
||||
|
||||
If You Are Developing PHP
|
||||
|
||||
|
||||
|
||||
|
||||
Extension developers:
|
||||
|
||||
Makefile.ins are abandoned. The files which are to be compiled
|
||||
are specified in the config.m4 now using the following macro:
|
||||
|
||||
PHP_NEW_EXTENSION(foo, foo.c bar.c baz.cpp, $ext_shared)
|
||||
|
||||
E.g. this enables the extension foo which consists of three source-code
|
||||
modules, two in C and one in C++. And dependending on the user's
|
||||
wishes, the extension will even be built as a dynamic module.
|
||||
|
||||
The full syntax:
|
||||
|
||||
PHP_NEW_EXTENSION(extname, sources [, shared [,sapi_class[, extra-cflags]]])
|
||||
|
||||
Please have a look at acinclude.m4 for the gory details and meanings
|
||||
of the other parameters.
|
||||
|
||||
And that's basically it for the extension side.
|
||||
|
||||
If you previously built sub-libraries for this module, add
|
||||
the source-code files here as well. If you need to specify
|
||||
separate include directories, do it this way:
|
||||
|
||||
PHP_NEW_EXTENSION(foo, foo.c mylib/bar.c mylib/gregor.c,,,-I@ext_srcdir@/lib)
|
||||
|
||||
E.g. this builds the three files which are located relative to the
|
||||
extension source directory and compiles all three files with the
|
||||
special include directive (@ext_srcdir@ is automatically replaced).
|
||||
|
||||
Now, you need to tell the build system that you want to build files
|
||||
in a directory called $ext_builddir/lib:
|
||||
|
||||
PHP_ADD_BUILD_DIR($ext_builddir/lib)
|
||||
|
||||
Make sure to call this after PHP_NEW_EXTENSION, because $ext_builddir
|
||||
is only set by the latter.
|
||||
|
||||
If you have a complex extension, you might to need add special
|
||||
Make rules. You can do this by calling PHP_ADD_MAKEFILE_FRAGMENT
|
||||
in your config.m4 after PHP_NEW_EXTENSION.
|
||||
|
||||
This will read a file in the source-dir of your extension called
|
||||
Makefile.frag. In this file, $(builddir) and $(srcdir) will be
|
||||
replaced by the values which are correct for your extension
|
||||
and which are again determined by the PHP_NEW_EXTENSION macro.
|
||||
|
||||
Make sure to prefix *all* relative paths correctly with either
|
||||
$(builddir) or $(srcdir). Because the build system does not
|
||||
change the working directory anymore, we must use either
|
||||
absolute paths or relative ones to the top build-directory.
|
||||
Correct prefixing ensures that.
|
||||
|
||||
|
||||
SAPI developers:
|
||||
|
||||
Instead of using PHP_SAPI=foo/PHP_BUILD_XYZ, you will need to type
|
||||
|
||||
PHP_SELECT_SAPI(name, type, sources.c)
|
||||
|
||||
I.e. specify the source-code files as above and also pass the
|
||||
information regarding how PHP is supposed to be built (shared
|
||||
module, program, etc).
|
||||
|
||||
For example for APXS:
|
||||
|
||||
PHP_SELECT_SAPI(apache, shared, sapi_apache.c mod_php4.c php_apache.c)
|
||||
|
||||
|
||||
|
||||
General info
|
||||
|
||||
The foundation for the new system is the flexible handling of
|
||||
sources and their contexts. With the help of macros you
|
||||
can define special flags for each source-file, where it is
|
||||
located, in which target context it can work, etc.
|
||||
|
||||
Have a look at the well documented macros
|
||||
PHP_ADD_SOURCES(_X) in acinclude.m4.
|
||||
-126
@@ -1,126 +0,0 @@
|
||||
Using PHP4 with the Zeus Web Server
|
||||
-----------------------------------
|
||||
|
||||
Zeus fully supports running PHP in combination with our
|
||||
webserver. There are three different interfaces that can be used to
|
||||
enable PHP:
|
||||
|
||||
* CGI
|
||||
* ISAPI
|
||||
* FastCGI
|
||||
|
||||
Of the three, we recommend using FastCGI, which has been tested and
|
||||
benchmarked as providing the best performance and reliability.
|
||||
|
||||
Full details of how to install PHP are available from our
|
||||
website, at:
|
||||
|
||||
http://support.zeus.com/products/php.html
|
||||
|
||||
If you have any problems, please check the support site for more
|
||||
up-to-date information and advice.
|
||||
|
||||
|
||||
Quick guide to installing FastCGI with Zeus
|
||||
-------------------------------------------
|
||||
|
||||
Step 1 - obtain and install FastCGI development kit.
|
||||
|
||||
Grab the package from:
|
||||
http://www.fastcgi.com/dist/devkit_2.2.0.tar.gz
|
||||
|
||||
Extract the package and follow the instructions:
|
||||
./configure
|
||||
make
|
||||
make export
|
||||
(run the last as root)
|
||||
|
||||
This will install to /usr/local/lib/libfcgi.a
|
||||
and /usr/local/include/*fcgi*
|
||||
|
||||
|
||||
|
||||
Step 2 - Compile PHP as FastCGI.
|
||||
|
||||
Compile as follows:
|
||||
./configure --with-fastcgi
|
||||
make
|
||||
|
||||
Note that PHP has many options to the configure script -
|
||||
e.g. --with-mysql. You will probably want to select your usual options
|
||||
before compiling; the above is just a bare minimum, for illustration.
|
||||
|
||||
After compilation finishes, you will be left with an executable
|
||||
program called 'php'. Copy this into your document root, under a
|
||||
dedicated FastCGI directory (e.g. $DOCROOT/fcgi-bin/php)
|
||||
|
||||
|
||||
Step 3 - configure Zeus
|
||||
|
||||
Four stages:
|
||||
- enable FastCGI
|
||||
- configure FastCGI
|
||||
- setup alias for FastCGI
|
||||
- setup alias for PHP
|
||||
|
||||
1) Using the admin server, go to the 'module configuration' page for
|
||||
your virtual server, and ensure that 'fastcgi' is enabled (select the
|
||||
tickbox to the left).
|
||||
|
||||
2) While we can run FastCGI's locally, there are known problems with
|
||||
some OS's (specifically, the communication between web server and
|
||||
FastCGI happens over a unix domain socket, and some OS's have trouble
|
||||
sustaining high connection rates over these sockets). So instead, we
|
||||
are going to set up the PHP FastCGI to run 'remotely' over localhost
|
||||
(this uses TCP sockets, which do not suffer this problem). Go to the
|
||||
'fastcgi configuration' page, and under 'add remote fastcgi':
|
||||
Add Remote FastCGI
|
||||
Docroot path /fcgi-bin/php
|
||||
Remote machine localhost:8002
|
||||
The first entry is where you saved PHP, above.
|
||||
The second entry is localhost:<any unused port>
|
||||
We will start the FastCGI listening on this port shortly.
|
||||
Click 'update' to commit these changes.
|
||||
|
||||
3) Go to the path mapping module and add an alias for FastCGI:
|
||||
Add Alias
|
||||
Docroot path /fcgi-bin
|
||||
Filesystem directory /path/to/docroot/fcgi-bin
|
||||
Alias type fastcgi
|
||||
Click 'update' to commit these changes
|
||||
|
||||
4) Also on the path mapping module, add a handler for PHP:
|
||||
Add handler
|
||||
File extension php
|
||||
Handler /fcgi-bin/php
|
||||
Click 'update' to commit these changes
|
||||
|
||||
Finally restart your virtual server for these changes to take effect.
|
||||
|
||||
|
||||
Step 4 - start PHP as a FastCGI runner
|
||||
|
||||
When you start PHP, it will pre-fork a given number of child processes
|
||||
to handle incoming PHP requests. Each process will handle a given
|
||||
number of requests before exiting (and being replaced by a newly
|
||||
forked process). You can control these two parameters by setting the
|
||||
following environment variables BEFORE starting the FastCGI runner:
|
||||
|
||||
PHP_FCGI_CHILDREN - the number of child processes to pre-fork. If not
|
||||
set, defaults to 8.
|
||||
|
||||
PHP_FCGI_MAX_REQUESTS - the number of requests each PHP child process
|
||||
handles before exiting. If not set, defaults to 500.
|
||||
|
||||
To start the FastCGI runner, execute '$ZEUSHOME/web/bin/fcgirunner
|
||||
8002 $DOCROOT/fcgi-bin/php'. Substitute the appropriate values for
|
||||
$ZEUSHOME and $DOCROOT; also substitute for 8002 the port you chose,
|
||||
above.
|
||||
|
||||
To stop the runner (e.g. to experiment with the above environment
|
||||
variables) you will need to manually stop and running PHP
|
||||
processes. (Use 'ps' and 'kill'). As it is PHP which is forking lots
|
||||
of children and not the runner, Zeus unfortunately cannot keep track
|
||||
of what processes are running, sorry. A typical command line may look
|
||||
like 'ps -efl | grep $DOCROOT/fcgi-bin/php | grep -v grep | awk
|
||||
'{print $4}' | xargs kill'
|
||||
@@ -1,170 +0,0 @@
|
||||
Things to do or at least think about doing in the future. Name in
|
||||
parenthesis means that person has taken on this project.
|
||||
|
||||
Zend
|
||||
----
|
||||
For PHP 4.3.0:
|
||||
* Allow foreach ($array as $k => &$val) syntax. right now we cannot
|
||||
traverse an array without copying each element.
|
||||
* Allow foreach ($array as $k => list($a, $b)) syntax for multi
|
||||
dimensional arrays.
|
||||
* Look at replacing c-lib call tolower().
|
||||
* Make hash API functions work with HASH_OF() to save time.
|
||||
* Allow to set a default value for call-by-reference-parameters.
|
||||
eg: function hello (&$pallo = NULL) {}
|
||||
* Disallow function(method) redefinition in class.
|
||||
* Add configure test to determine if dlsym() requires underscore and set
|
||||
DLSYM_NEEDS_UNDERSCORE accordingly. Perl and zsh have it in configure,
|
||||
for example. (DONE?)
|
||||
|
||||
For PHP 5.0.0:
|
||||
* Native large number support (probably with GNU GMP)
|
||||
* Const'ify APIs. Right now, many functions leave parameters untouched,
|
||||
but don't declare those as const. This makes interaction with other
|
||||
interfaces difficult which pass const parameters to us.
|
||||
|
||||
|
||||
global
|
||||
------
|
||||
For PHP 4.3.0:
|
||||
* Add aliases to functions to conform to new naming conventions, e.g.
|
||||
str_to_upper().
|
||||
* Make all extensions thread-safe.
|
||||
* Make everything on the language-level independent of your locale
|
||||
settings.
|
||||
* Change PHP error messages, so that they point to pages or sections
|
||||
in the PHP Manual.
|
||||
* Make sure that all ZTS globals get destructed. Most ts_allocate_id()
|
||||
calls should have a dtor entry.
|
||||
* Activate all extensions by default that don't rely on external
|
||||
dependencies. (eg ftp) (DONE?)
|
||||
* on some platforms unimplemented function will just do nothing
|
||||
(e.g. symlink) they should print a warning or not even be defined!
|
||||
(DONE ?)
|
||||
* Use arg_separator.input to implode args in the CGI sapi extension
|
||||
and arg_separator.input to explode in php_build_argv(). (DONE?)
|
||||
* Change the odbc_fetch_into() function to require ALWAYS the first two
|
||||
parameters ($conn_id and $array), and make the third (row) be optional.
|
||||
* Remove --with-openlink configure option (--with-iodbc replaces it).
|
||||
* Implement flush feature suitable for nested output buffers.
|
||||
|
||||
For PHP 5.0.0
|
||||
* bundle and use curl lib for fopen wrapper.
|
||||
* --enable-all in configure. (--enable-shared=max ...)
|
||||
* make configure print out a summary when it's done (like XEmacs)
|
||||
* replace standard functions which work on static data with
|
||||
reentrancy-safe functions (DONE?).
|
||||
* make SAPI conform to CGI/1.1. Currently, all SAPI modules
|
||||
define REMOTE_ADDR etc. themselves and reach only various level
|
||||
of compliance.
|
||||
* see what functions might need to be changed to use HashPosition, so
|
||||
that the internal array pointer is not affected.
|
||||
* Move most extensions and PEAR packages out of the PHP CVS tree,
|
||||
include them again during release packaging.
|
||||
|
||||
|
||||
Other
|
||||
* use thread-safe resolver functions (either require BIND 8 or adns).
|
||||
* implement javadoc based function docs template system.
|
||||
* provide optional IPv6 support.
|
||||
* find a better way to implement script timeouts. SIGVTALRM is used
|
||||
by some POSIX threads implementations (i.e. OpenBSD) and is not
|
||||
available in ZTS mode.
|
||||
|
||||
|
||||
documentation
|
||||
-------------
|
||||
* Add remarks in the documentation which functions are not implemented
|
||||
on win32.
|
||||
* Add remarks in the documentation which functions are not binary-safe.
|
||||
* Update curl documentation (DONE?)
|
||||
* Add developer documentation.
|
||||
* Add detailed documentation for Java extension.
|
||||
|
||||
ext/bz2
|
||||
-------
|
||||
* Add ini setting for decompression buffer size. The default 4k is to small
|
||||
for big files and takes ages to decompress. However, 40k which perform
|
||||
quite good with big files may be to much under certain environments as
|
||||
default setting. There should be consideren different default sizes for
|
||||
different SAPIS (e.g. apache and cli).
|
||||
|
||||
ext/curl
|
||||
--------
|
||||
* Have a warning scheme for when people use unsupported features.
|
||||
|
||||
ext/oci8
|
||||
--------
|
||||
* All OCIFetch*() functions should return 0 for no more data and false on
|
||||
error.
|
||||
* Have a flag that trims trailing spaces from CHAR fields on retrieval.
|
||||
* Make allow_call_time_pass_reference=Off working.
|
||||
* For additional todo information, see oci8.c, in ext/oci8
|
||||
|
||||
ext/pcre
|
||||
--------
|
||||
* Allow user to set PCRE_NOTEMPTY, PCRE_ANCHORED at execution time, maybe
|
||||
|
||||
ext/pcntl
|
||||
---------
|
||||
* Change internal callback handler to use TICKS
|
||||
* Remove all zend_extension code
|
||||
* Add object callback support to pcntl_signal()
|
||||
|
||||
ext/pgsql
|
||||
---------
|
||||
For PHP 4.3.0:
|
||||
* Add pg_metadata() with metadata cache feature.
|
||||
* Add pg_convert() to check and convert array value for query.
|
||||
* Add pg_insert/pg_update/pg_delete/pg_select for simple query.
|
||||
|
||||
ext/session
|
||||
-----------
|
||||
For PHP 4.3.0:
|
||||
* session_abort() to abort session. ie: Do not save session data.
|
||||
* Allow unset($_SESSION) or unset($HTTP_SESSION_VARS) to unset
|
||||
session vars regardless of register_globals setting.
|
||||
|
||||
Other:
|
||||
* Maybe implement finer-grained session variables that could be
|
||||
locked individually.
|
||||
* Write a network-transparent storage back-end with fallover
|
||||
facilities
|
||||
* Provide a callback facility which is executed upon encountering
|
||||
an unknown class name during deserialization
|
||||
|
||||
ext/sockets
|
||||
-----------
|
||||
* Implement IPv6
|
||||
* Review/Fix vectors
|
||||
|
||||
ext/standard
|
||||
------------
|
||||
* Add a version number to data serialized via serialize().
|
||||
* Possibly modify parsing of GPC data to automatically create arrays if
|
||||
variable name is seen more than once.
|
||||
* Implement regex-cache for url-functions.
|
||||
* stri_replace(). (Andrei)
|
||||
* Move socket related functions to fsock.c.
|
||||
* NOT binary safe:
|
||||
strtok()
|
||||
basename()
|
||||
dirname()
|
||||
strrpos()
|
||||
strrchr()
|
||||
strip_tags()
|
||||
|
||||
ext/wddx
|
||||
--------
|
||||
* See if we can support the remaining data types:
|
||||
dateTime
|
||||
binary
|
||||
|
||||
http://www.wddx.org/WDDX_SDK_10a/7__References/WDDX_DTD.htm
|
||||
(Andrei)
|
||||
|
||||
* implement wddx_packet_as_javascript(). (Andrei)
|
||||
|
||||
other cool stuff
|
||||
----------------
|
||||
* PVM extension
|
||||
@@ -1,3 +0,0 @@
|
||||
- clean up .cvsignores
|
||||
- purge Makefile.ins and replace PHP_EXTENSION in config.m4s
|
||||
with appropiate calls to PHP_NEW_EXTENSION
|
||||
@@ -1 +0,0 @@
|
||||
/* Leave this file alone */
|
||||
-1473
File diff suppressed because it is too large.
Load diff
-280
@@ -1,280 +0,0 @@
|
||||
Following is a merge of two letters I sent to php4beta@lists.php.net,
|
||||
describing the changes in API between PHP 3.0 and PHP 4.0 (Zend).
|
||||
This file is by no means thorough documentation of the PHP API,
|
||||
and is intended for developers who are familiar with the PHP 3.0 API,
|
||||
and want to port their code to PHP 4.0, or take advantage of its new
|
||||
features. For highlights about the PHP 3.0 API, consult apidoc.txt.
|
||||
|
||||
Zeev
|
||||
|
||||
--------------------------------------------------------------------------
|
||||
|
||||
I'm going to try to list the important changes in API and programming
|
||||
techniques that are involved in developing modules for PHP4/Zend, as
|
||||
opposed to PHP3. Listing the whole PHP4 API is way beyond my scope here,
|
||||
it's mostly a 'diff' from the apidoc.txt, which you're all pretty familiar
|
||||
with.
|
||||
An important note that I neglected to mention yesterday - the php4 tree is
|
||||
based on the php 3.0.5 tree, plus all 3.0.6 patches hand-patched into it.
|
||||
Notably, it does NOT include any 3.0.7 patches. All of those have to be
|
||||
reapplied, with extreme care - modules should be safe to patch (mostly),
|
||||
but anything that touches the core or main.c will almost definitely require
|
||||
changes in order to work properly.
|
||||
|
||||
[1] Symbol Tables
|
||||
|
||||
One of the major changes in Zend involves changing the way symbols tables
|
||||
work. Zend enforces reference counting on all values and resources. This
|
||||
required changes in the semantics of the hash tables that implement symbol
|
||||
tables. Instead of storing pval in the hashes, we now store pval *. All
|
||||
of the API functions in Zend were changed in a way that this change is
|
||||
completely transparent. However, if you've used 'low level' hash functions
|
||||
to access or update elements in symbol tables, your code will require
|
||||
changes. Following are two simple examples, one demonstrates the
|
||||
difference between PHP3 and Zend when reading a symbol's value, and the
|
||||
other demonstrates the difference when writing a value.
|
||||
|
||||
php3_read()
|
||||
{
|
||||
pval *foo;
|
||||
|
||||
_php3_hash_find(ht, "foo", sizeof("foo"), &foo);
|
||||
/* foo->type is the type and foo->value is the value */
|
||||
}
|
||||
|
||||
|
||||
php4_read()
|
||||
{
|
||||
pval **foo;
|
||||
|
||||
_php3_hash_find(ht, "foo", sizeof("foo"), &foo);
|
||||
/* (*foo)->type is the type and (*foo)->value is the value */
|
||||
}
|
||||
|
||||
---
|
||||
|
||||
php3_write()
|
||||
{
|
||||
pval newval;
|
||||
|
||||
newval.type = ...;
|
||||
newval.value = ...;
|
||||
_php3_hash_update(ht, "bar", sizeof("bar"), &newval, sizeof(pval), NULL);
|
||||
}
|
||||
|
||||
php4_write()
|
||||
{
|
||||
pval *newval = ALLOC_ZVAL();
|
||||
|
||||
newval->refcount=1;
|
||||
newval->is_ref=0;
|
||||
newval->type = ...;
|
||||
newval->value = ...;
|
||||
_php3_hash_update(ht, "bar", sizeof("bar"), &newval, sizeof(pval *), NULL);
|
||||
}
|
||||
|
||||
|
||||
[2] Resources
|
||||
|
||||
One of the 'cute' things about the reference counting support is that it
|
||||
completely eliminates the problem of resource leaking. A simple loop that
|
||||
included '$result = mysql_query(...)' in PHP leaked unless the user
|
||||
remembered to run mysql_free($result) at the end of the loop body, and
|
||||
nobody really did. In order to take advantage of the automatic resource
|
||||
deallocation upon destruction, there's virtually one small change you need
|
||||
to conduct. Change the result type of a resource that you want to destroy
|
||||
itself as soon as its no longer referenced (just about any resource I can
|
||||
think of) as IS_RESOURCE, instead of as IS_LONG. The rest is magic.
|
||||
|
||||
A special treatment is required for SQL modules that follow MySQL's
|
||||
approach for having the link handle as an optional argument. Modules that
|
||||
follow the MySQL module model, store the last opened link in a global
|
||||
variable, that they use in case the user neglects to explicitly specify a
|
||||
link handle. Due to the way referenec counting works, this global
|
||||
reference is just like any other reference, and must increase that SQL link
|
||||
resource's reference count (otherwise, it will be closed prematurely).
|
||||
Simply, when you set the default link to a certain link, increase that
|
||||
link's reference count by calling zend_list_addref().
|
||||
As always, the MySQL module is the one used to demonstrate 'new
|
||||
technology'. You can look around it and look for IS_RESOURCE, as well as
|
||||
zend_list_addref(), to see a clear example of how the new API should be used.
|
||||
|
||||
|
||||
[3] Thread safety issues
|
||||
|
||||
I'm not going to say that Zend was designed with thread safety in mind, but
|
||||
from some point, we've decided upon several guidelines that would make the
|
||||
move to thread safety much, much easier. Generally, we've followed the PHP
|
||||
3.1 approach of moving global variables to a structure, and encapsulating
|
||||
all global variable references within macros. There are three main
|
||||
differences:
|
||||
1. We grouped related globals in a single structure, instead of grouping
|
||||
all globals in one structure.
|
||||
2. We've used much, much shorter macro names to increase the readability
|
||||
of the source code.
|
||||
3. Regardless of whether we're compiling in thread safe mode or not, all
|
||||
global variables are *always* stored in a structure. For example, you
|
||||
would never have a global variable 'foo', instead, it'll be a property of a
|
||||
global structure, for example, compiler_globals.foo. That makes
|
||||
development much, much easier, since your code will simply not compile
|
||||
unless you remember to put the necessary macro around foo.
|
||||
|
||||
To write code that'll be thread safe in the future (when we release our
|
||||
thread safe memory manager and work on integrating it), you can take a look
|
||||
at zend_globals.h. Essentially, two sets of macros are defined, one for
|
||||
thread safe mode, and one for thread unsafe mode. All global references
|
||||
are encapsulated within ???G(varname), where ??? is the appropriate prefix
|
||||
for your structure (for example, so far we have CG(), EG() and AG(), which
|
||||
stand for the compiler, executor and memory allocator, respectively).
|
||||
When compiling with thread safety enabled, each function that makes use of
|
||||
a ???G() macro, must obtain the pointer to its copy of the structure. It
|
||||
can do so in one of two forms:
|
||||
1. It can receive it as an argument.
|
||||
2. It can fetch it.
|
||||
|
||||
Obviously, the first method is preferable since it's much quicker.
|
||||
However, it's not always possible to send the structure all the way to a
|
||||
particular function, or it may simply bloat the code too much in some
|
||||
cases. Functions that receive the globals as an argument, should look like
|
||||
this:
|
||||
|
||||
rettype functioname(???LS_D) <-- a function with no arguments
|
||||
rettype functioname(type arg1, ..., type argn ???LS_DC) <-- a funciton with
|
||||
arguments
|
||||
|
||||
Calls to such functions should look like this:
|
||||
functionname(???LS_C) <-- a function with no arguments
|
||||
functionname(arg1, ..., argn ???LS_CC) <-- a function with arguments
|
||||
|
||||
LS stands for 'Local Storage', _C stands for Call and _CC stands for Call
|
||||
Comma, _D stands for Declaration and _DC stands for Declaration Comma.
|
||||
Note that there's NO comma between the last argument and ???LS_DC or ???LS_CC.
|
||||
|
||||
If you do not pass the structure as an argument you can always fetch it by
|
||||
using the appropriate ???LS_FETCH() macros within a functions variable
|
||||
declarations.
|
||||
|
||||
In general, every module that makes use of globals should use this approach
|
||||
if it plans to be thread safe.
|
||||
|
||||
|
||||
[4] Generalized INI support
|
||||
|
||||
The code comes to solve several issues:
|
||||
|
||||
a. The ugly long block of code in main.c that reads values from the
|
||||
cfg_hash into php3_ini.
|
||||
b. Get rid of php3_ini. The performance penalty of copying it around all
|
||||
the time in the Apache module probably wasn't too high, but
|
||||
psychologically, it annoyed me :)
|
||||
c. Get rid of the ugly code in mod_php4.c, that also reads values from
|
||||
Apache directives and puts them into the php3_ini structure.
|
||||
d. Generalize all the code so that you only have to add an entry in one
|
||||
single place and get it automatically supported in php3.ini, Apache, Win32
|
||||
registry, runtime function ini_get() and ini_alter() and any future method
|
||||
we might have.
|
||||
e. Allow users to easily override *ANY* php3.ini value, except for ones
|
||||
they're not supposed to, of course.
|
||||
|
||||
I'm happy to say that I think I pretty much reached all goals. php_ini.c
|
||||
implements a mechanism that lets you add your INI entry in a single place,
|
||||
with a default value in case there's no php3.ini value. What you get by
|
||||
using this mechanism:
|
||||
|
||||
1. Automatic initialization from php3.ini if available, or from the
|
||||
default value if not.
|
||||
2. Automatic support in ini_alter(). That means a user can change the
|
||||
value for this INI entry at runtime, without you having to add in a single
|
||||
line of code, and definitely no additional function (for example, in PHP3,
|
||||
we had to add in special dedicated functions, like
|
||||
set_magic_quotes_runtime() or the likes - no need for that anymore).
|
||||
3. Automatic support in Apache .conf files.
|
||||
4. No need for a global php3_ini-like variable that'll store all that
|
||||
info. You can directly access each INI entry by name, in runtime. 'Sure,
|
||||
that's not revolutionary, it's just slow' is probably what some of you
|
||||
think - which is true, but, you can also register a callback function that
|
||||
is called each time your INI entry is changed, if you wish to store it in a
|
||||
cached location for intensive use.
|
||||
5. Ability to access the current active value for a given INI entry, and
|
||||
the 'master' value.
|
||||
|
||||
Of course, (2) and (3) are only applicable in some cases. Some entries
|
||||
shouldn't be overriden by users in runtime or through Apache .conf files -
|
||||
you can, of course, mark them as such.
|
||||
|
||||
|
||||
So, enough hype, how does it work.
|
||||
|
||||
Essentially:
|
||||
|
||||
static PHP_INI_MH(OnChangeBar); /* declare a message handler for a change
|
||||
in "bar" */
|
||||
|
||||
PHP_INI_BEGIN()
|
||||
PHP_INI_ENTRY("foo", "1", PHP_INI_ALL, NULL, NULL)
|
||||
PHP_INI_ENTRY("bar", "bah", PHP_INI_SYSTEM, OnChangeBar, NULL)
|
||||
PHP_INI_END()
|
||||
|
||||
static PHP_INI_MH(OnChangeBar)
|
||||
{
|
||||
a_global_var_for_bar = new_value;
|
||||
return SUCCESS;
|
||||
}
|
||||
|
||||
int whatever_minit(INIT_FUNC_ARGS)
|
||||
{
|
||||
...
|
||||
REGISTER_INI_ENTRIES();
|
||||
...
|
||||
}
|
||||
|
||||
|
||||
int whatever_mshutdown(SHUTDOWN_FUNC_ARGS)
|
||||
{
|
||||
...
|
||||
UNREGISTER_INI_ENTRIES();
|
||||
...
|
||||
}
|
||||
|
||||
|
||||
and that's it. Here's what it does. As you can probably guess, this code
|
||||
registers two INI entries - "foo" and "bar". They're given defaults "1"
|
||||
and "bah" respectively - note that all defaults are always given as
|
||||
strings. That doesn't reduce your ability to use integer values, simply
|
||||
specify them as strings. "foo" is marked so that it can be changed by
|
||||
anyone at any time (PHP_INI_ALL), whereas "bar" is marked so it can be
|
||||
changed only at startup in the php3.ini only, presumably, by the system
|
||||
administrator (PHP_INI_SYSTEM).
|
||||
When "foo" changes, no function is called. Access to it is done using the
|
||||
macros INI_INT("foo"), INI_FLT("foo") or INI_STR("foo"), which return a
|
||||
long, double or char * respectively (strings that are returned aren't
|
||||
duplicated - if they're manipulated, you must duplicate them first). You
|
||||
can also access the original value (the 'master' value, in case one of them
|
||||
was overriden by a user) using another pair of macros:
|
||||
INI_ORIG_INT("foo"), INI_ORIG_FLT("foo") and INI_ORIG_STR("foo").
|
||||
|
||||
When "bar" changes, a special message handler is called, OnBarChange().
|
||||
Always declare those message handlers using PHP_INI_MH(), as they might
|
||||
change in the future. Message handlers are called as soon as an ini entry
|
||||
initializes or changes, and allow you to cache a certain INI value in a
|
||||
quick C structure. In this example, whenever "bar" changes, the new value
|
||||
is stored in a_global_var_for_bar, which is a global char * pointer,
|
||||
quickly accessible from other functions. Things get a bit more complicated
|
||||
when you want to implement a thread-safe module, but it's doable as well.
|
||||
Message handlers may return SUCCESS to acknowledge the new value, or
|
||||
FAILURE to reject it. That enables you to reject invalid values for some
|
||||
INI entries if you want. Finally, you can have a pointer passed to your
|
||||
message handler - that's the fifth argument to PHP_INI_ENTRY(). It is
|
||||
passed as mh_arg to the message handler.
|
||||
|
||||
Remember that for certain values, there's really no reason to mess with a
|
||||
callback function. A perfect example for this are the syntax highlight
|
||||
colors, which no longer have a dedicated global C slot that stores them,
|
||||
but instead, are fetched from the php_ini hash on demand.
|
||||
|
||||
"As always", for a perfect working example of this mechanism, consult
|
||||
functions/mysql.c. This module uses the new INI entry mechanism, and was
|
||||
also converted to be thread safe in general, and in its php_ini support in
|
||||
particular. Converting your modules to look like this for thread safety
|
||||
isn't a bad idea (not necessarily now, but in the long run).
|
||||
|
||||
-492
@@ -1,492 +0,0 @@
|
||||
PHP Version 3.0 API Documentation
|
||||
|
||||
Table of Contents
|
||||
-----------------
|
||||
1. Function Prototype
|
||||
2. Function Arguments
|
||||
3. Variable number of function arguments
|
||||
4. Using the function arguments
|
||||
5. Memory management in functions
|
||||
6. Setting variables in the symbol table
|
||||
7. Returning values from functions
|
||||
8. Returning 'complex' values from functions (arrays or objects)
|
||||
9. Using the resource list
|
||||
10. Using the persistent resource table
|
||||
11. Adding runtime configuration directives
|
||||
-----------------
|
||||
|
||||
1. Function Prototype
|
||||
|
||||
All functions look like this:
|
||||
|
||||
PHP_FUNCTION(foo) {
|
||||
|
||||
}
|
||||
|
||||
Even if your function doesn't take any arguments, this is how it is
|
||||
called.
|
||||
|
||||
-----------------
|
||||
|
||||
2. Function Arguments
|
||||
|
||||
Arguments are always of type pval. This type contains a union which
|
||||
has the actual type of the argument. So, if your function takes two
|
||||
arguments, you would do something like the following at the top of your
|
||||
function:
|
||||
|
||||
pval *arg1, *arg2;
|
||||
if (ARG_COUNT(ht) != 2 || getParameters(ht,2,&arg1,&arg2)==FAILURE) {
|
||||
WRONG_PARAM_COUNT;
|
||||
}
|
||||
|
||||
NOTE: Arguments can be passed either by value or by reference. In both
|
||||
cases you will need to pass &(pval *) to getParameters. If you want to
|
||||
check if the n'th parameter was sent to you by reference or not, you can
|
||||
use the function, ParameterPassedByReference(ht,n). It will return either
|
||||
1 or 0.
|
||||
|
||||
When you change any of the passed parameters, whether they are sent by
|
||||
reference or by value, you can either start over with the parameter by
|
||||
calling pval_destructor on it, or if it's an ARRAY you want to add to,
|
||||
you can use functions similar to the ones in internal_functions.h which
|
||||
manipulate return_value as an ARRAY.
|
||||
|
||||
Also if you change a parameter to IS_STRING make sure you first assign
|
||||
the new estrdup'ed string and the string length, and only later change the
|
||||
type to IS_STRING. If you change the string of a parameter which already
|
||||
IS_STRING or IS_ARRAY you should run pval_destructor on it first.
|
||||
|
||||
-----------------
|
||||
|
||||
3. Variable number of function arguments
|
||||
|
||||
A function can take a variable number of arguments. If your function can
|
||||
take either 2 or 3 arguments, use the following:
|
||||
|
||||
pval *arg1, *arg2, *arg3;
|
||||
int arg_count = ARG_COUNT(ht);
|
||||
|
||||
if (arg_count<2 || arg_count>3 ||
|
||||
getParameters(ht,arg_count,&arg1,&arg2,&arg3)==FAILURE) {
|
||||
WRONG_PARAM_COUNT;
|
||||
}
|
||||
|
||||
------------------
|
||||
|
||||
4. Using the function arguments
|
||||
|
||||
The type of each argument is stored in the pval type field:
|
||||
|
||||
|
||||
This type can be any of the following:
|
||||
|
||||
IS_STRING String
|
||||
IS_DOUBLE Double-precision floating point
|
||||
IS_LONG Long
|
||||
IS_ARRAY Array
|
||||
|
||||
IS_EMPTY ??
|
||||
IS_USER_FUNCTION ??
|
||||
IS_INTERNAL_FUNCTION ?? (if some of these cannot be passed to a
|
||||
function - delete)
|
||||
IS_CLASS ??
|
||||
IS_OBJECT ??
|
||||
|
||||
If you get an argument of one type and would like to use it as another,
|
||||
or if you just want to force the argument to be of a certain type, you
|
||||
can use one of the following conversion functions:
|
||||
|
||||
convert_to_long(arg1);
|
||||
convert_to_double(arg1);
|
||||
convert_to_string(arg1);
|
||||
convert_to_boolean_long(arg1); If the string is "" or "0" it
|
||||
becomes 0, 1 otherwise
|
||||
convert_string_to_number(arg1); Converts string to either LONG or
|
||||
DOUBLE depending on string
|
||||
|
||||
These function all do in-place conversion. They do not return anything.
|
||||
|
||||
The actual argument is stored in a union.
|
||||
|
||||
For type IS_STRING, use arg1->value.str.val
|
||||
IS_LONG arg1->value.lval
|
||||
IS_DOUBLE arg1->value.dval
|
||||
|
||||
-------------------
|
||||
|
||||
5. Memory management in functions
|
||||
|
||||
Any memory needed by a function should be allocated with either emalloc()
|
||||
or estrdup(). These are memory handling abstraction functions that look
|
||||
and smell like the normal malloc() and strdup() functions. Memory should
|
||||
be freed with efree().
|
||||
|
||||
There are two kinds of memory in this program. Memory which is returned
|
||||
to the parser in a variable and memory which you need for temporary
|
||||
storage in your internal function. When you assign a string to a
|
||||
variable which is returned to the parser you need to make sure you first
|
||||
allocate the memory with either emalloc or estrdup. This memory
|
||||
should NEVER be freed by you, unless you later, in the same function
|
||||
overwrite your original assignment (this kind of programming practice is
|
||||
not good though).
|
||||
|
||||
For any temporary/permanent memory you need in your functions/library you
|
||||
should use the three emalloc(), estrdup(), and efree() functions. They
|
||||
behave EXACTLY like their counterpart functions. Anything you emalloc()
|
||||
or estrdup() you have to efree() at some point or another, unless it's
|
||||
supposed to stick around until the end of the program, otherwise there
|
||||
will be a memory leak. The meaning of "the functions behave exactly like
|
||||
their counterparts" is if you efree() something which was not
|
||||
emalloc()'ed nor estrdup()'ed you might get a segmentation fault. So
|
||||
please take care and free all of your wasted memory. One of the biggest
|
||||
improvements in PHP 3.0 will hopefully be the memory management.
|
||||
|
||||
If you compile with "-DDEBUG", PHP3 will print out a list of all
|
||||
memory that was allocated using emalloc() and estrdup() but never
|
||||
freed with efree() when it is done running the specified script.
|
||||
|
||||
-------------------
|
||||
|
||||
6. Setting variables in the symbol table
|
||||
|
||||
A number of macros are available which make it easier to set a variable
|
||||
in the symbol table:
|
||||
|
||||
SET_VAR_STRING(name,value) **
|
||||
SET_VAR_DOUBLE(name,value)
|
||||
SET_VAR_LONG(name,value)
|
||||
|
||||
** Be careful here. The value part must be malloc'ed manually because
|
||||
the memory management code will try to free this pointer later. Do
|
||||
not pass statically allocated memory into a SET_VAR_STRING
|
||||
|
||||
Symbol tables in PHP 3.0 are implemented as hash tables. At any given time,
|
||||
&symbol_table is a pointer to the 'main' symbol table, and active_symbol_table
|
||||
points to the currently active symbol table (these may be identical like in
|
||||
startup, or different, if you're inside a function).
|
||||
|
||||
The following examples use 'active_symbol_table'. You should replace it with
|
||||
&symbol_table if you specifically want to work with the 'main' symbol table.
|
||||
Also, the same funcions may be applied to arrays, as explained below.
|
||||
|
||||
* To check whether a variable named $foo already exists in a symbol table:
|
||||
if (hash_exists(active_symbol_table,"foo",sizeof("foo"))) { exists... }
|
||||
else { doesn't exist }
|
||||
|
||||
* If you also need to get the type of the variable, you can use:
|
||||
hash_find(active_symbol_table,"foo",sizeof("foo"),&pvalue);
|
||||
check(pvalue.type);
|
||||
|
||||
Arrays in PHP 3.0 are implemented using the same hashtables as symbol tables.
|
||||
This means the two above functions can also be used to check variables
|
||||
inside arrays.
|
||||
|
||||
If you want to define a new array in a symbol table, you should do this:
|
||||
|
||||
1. Possibly check it exists and abort, using hash_exists()
|
||||
or hash_find().
|
||||
2. Code:
|
||||
|
||||
pval arr;
|
||||
|
||||
if (array_init(&arr) == FAILURE) { failed... };
|
||||
hash_update(active_symbol_table,"foo",sizeof("foo"),&arr,sizeof(pval),NULL);
|
||||
|
||||
This code declares a new array, named $foo, in the active symbol table.
|
||||
This array is empty.
|
||||
|
||||
Here's how to add new entries to it:
|
||||
|
||||
pval entry;
|
||||
|
||||
entry.type = IS_LONG;
|
||||
entry.value.lval = 5;
|
||||
|
||||
hash_update(arr.value.ht,"bar",sizeof("bar"),&entry,sizeof(pval),NULL); /* defines $foo["bar"] = 5 */
|
||||
hash_index_update(arr.value.ht,7,&entry,sizeof(pval),NULL); /* defines $foo[7] = 5 */
|
||||
hash_next_index_insert(arr.value.ht,&entry,sizeof(pval),NULL); /* defines the next free place in $foo[],
|
||||
* $foo[8], to be 5 (works like php2)
|
||||
*/
|
||||
|
||||
If you'd like to modify a value that you inserted to a hash, you must first retreive it from the hash. To
|
||||
prevent that overhead, you can supply a pval ** to the hash add function, and it'll be updated with the
|
||||
pval * address of the inserted element inside the hash. If that value is NULL (like in all of the
|
||||
above examples) - that parameter is ignored.
|
||||
|
||||
hash_next_index_insert() works more or less using the same logic
|
||||
"$foo[] = bar;" works in PHP 2.0.
|
||||
|
||||
If you are building an array to return from a function, you can initialize
|
||||
the array just like above by doing:
|
||||
|
||||
if (array_init(return_value) == FAILURE) { failed...; }
|
||||
|
||||
and then adding values with the helper functions:
|
||||
|
||||
add_next_index_long(return_value,long_value);
|
||||
add_next_index_double(return_value,double_value);
|
||||
add_next_index_string(return_value,estrdup(string_value));
|
||||
|
||||
Of course, if the adding isn't done right after the array
|
||||
initialization, you'd probably have to look for the array first:
|
||||
|
||||
pval *arr;
|
||||
|
||||
if (hash_find(active_symbol_table,"foo",sizeof("foo"),(void **)&arr)==FAILURE) { can't find... }
|
||||
else { use arr->value.ht... }
|
||||
|
||||
Note that hash_find receives a pointer to a pval pointer, and
|
||||
not a pval pointer.
|
||||
|
||||
Just about any hash function returns SUCCESS or FAILURE (except for
|
||||
hash_exists() that returns a boolean truth value).
|
||||
|
||||
-------------------
|
||||
|
||||
7. Returning 'simple' values from functions (integers, floats or strings)
|
||||
|
||||
A number of macros are available to make it easier to return things from
|
||||
functions:
|
||||
|
||||
These set the return value and return from the function:
|
||||
|
||||
RETURN_FALSE
|
||||
RETURN_TRUE
|
||||
RETURN_LONG(l)
|
||||
RETURN_STRING(s,dup) If dup is true, duplicates the string
|
||||
RETURN_STRINGL(s,l,dup) Return string (s) specifying length (l).
|
||||
RETURN_DOUBLE(d)
|
||||
|
||||
These only set the return value:
|
||||
|
||||
RETVAL_FALSE
|
||||
RETVAL_TRUE
|
||||
RETVAL_LONG(l)
|
||||
RETVAL_STRING(s,dup) If dup is true, duplicates the string
|
||||
RETVAL_STRINGL(s,l,dup) Return string (s) specifying length (l).
|
||||
RETVAL_DOUBLE(d)
|
||||
|
||||
The string macros above will all estrdup() the passed 's' argument,
|
||||
so you can safely free the argument after calling the macro, or
|
||||
alternatively use statically allocated memory.
|
||||
|
||||
If your function returns boolean success/error responses, always use
|
||||
RETURN_TRUE and RETURN_FALSE respectively.
|
||||
|
||||
-------------------
|
||||
|
||||
8. Returning 'complex' values from functions (arrays or objects)
|
||||
|
||||
Your function can also return a complex data type such as an object
|
||||
or an array.
|
||||
|
||||
Returning an object:
|
||||
|
||||
1. Call object_init(return_value).
|
||||
2. Fill it up with values:
|
||||
|
||||
add_property_long(return_value,property_name,l) Add a property named 'property_name', of type long, equals to 'l'
|
||||
add_property_double(return_value,property_name,d) Same, only a double
|
||||
add_property_string(return_value,property_name,str) Same, only a string
|
||||
add_property_stringl(return_value,property_name,str,l) Add a property named 'property_name', of type string, string is 'str' with length 'l'
|
||||
|
||||
3. Possibly, register functions for this object. In order to
|
||||
obtain values from the object, the function would have to fetch
|
||||
"this" from the active_symbol_table. Its type should be IS_OBJECT,
|
||||
and it's basically a regular hash table (i.e., you can use regular
|
||||
hash functions on .value.ht). The actual registration of the
|
||||
function can be done using:
|
||||
|
||||
add_method(return_value,function_name,function_ptr)
|
||||
|
||||
|
||||
Returning an array:
|
||||
|
||||
1. Call array_init(return_value).
|
||||
2. Fill it up with values:
|
||||
|
||||
add_assoc_long(return_value,key,l) add associative entry with key 'key' and long value 'l'
|
||||
add_assoc_double(return_value,key,d)
|
||||
add_assoc_string(return_value,key,str)
|
||||
add_assoc_stringl(return_value,key,str,length) specify the string length
|
||||
|
||||
add_index_long(return_value,index,l) add entry in index 'index' with long value 'l'
|
||||
add_index_double(return_value,index,d)
|
||||
add_index_string(return_value,index,str)
|
||||
add_index_stringl(return_value,index,str,length) specify the string length
|
||||
|
||||
add_next_index_long(return_value,l) add an array entry in the next free offset with long value 'l'
|
||||
add_next_index_double(return_value,d)
|
||||
add_next_index_string(return_value,str)
|
||||
add_next_index_stringl(return_value,str,length) specify the string length
|
||||
|
||||
-------------------
|
||||
|
||||
9. Using the resource list
|
||||
|
||||
PHP 3.0 has a standard way of dealing with various types of resources,
|
||||
that replaces all of the local linked lists in PHP 2.0.
|
||||
|
||||
Available functions:
|
||||
|
||||
php3_list_insert(ptr, type) returns the 'id' of the newly inserted resource
|
||||
php3_list_delete(id) delete the resource with the specified id
|
||||
php3_list_find(id,*type) returns the pointer of the resource with the specified id, updates 'type' to the resource's type
|
||||
|
||||
Typically, these functions are used for SQL drivers but they can be
|
||||
used for anything else, and are used, for instance, for maintaining
|
||||
file descriptors.
|
||||
|
||||
Typical list code would look like this:
|
||||
|
||||
Adding a new resource:
|
||||
|
||||
RESOURCE *resource;
|
||||
|
||||
...allocate memory for resource and acquire resource...
|
||||
/* add a new resource to the list */
|
||||
return_value->value.lval = php3_list_insert((void *) resource, LE_RESOURCE_TYPE);
|
||||
return_value->type = IS_LONG;
|
||||
|
||||
Using an existing resource:
|
||||
|
||||
pval *resource_id;
|
||||
RESOURCE *resource;
|
||||
int type;
|
||||
|
||||
convert_to_long(resource_id);
|
||||
resource = php3_list_find(resource_id->value.lval, &type);
|
||||
if (type != LE_RESOURCE_TYPE) {
|
||||
php3_error(E_WARNING,"resource index %d has the wrong type",resource_id->value.lval);
|
||||
RETURN_FALSE;
|
||||
}
|
||||
...use resource...
|
||||
|
||||
Deleting an existing resource:
|
||||
|
||||
pval *resource_id;
|
||||
RESOURCE *resource;
|
||||
int type;
|
||||
|
||||
convert_to_long(resource_id);
|
||||
php3_list_delete(resource_id->value.lval);
|
||||
|
||||
|
||||
The resource types should be registered in php3_list.h, in enum
|
||||
list_entry_type. In addition, one should add shutdown code for any
|
||||
new resource type defined, in list.c's list_entry_destructor() (even if
|
||||
you don't have anything to do on shutdown, you must add an empty case).
|
||||
|
||||
-------------------
|
||||
|
||||
10. Using the persistent resource table
|
||||
|
||||
PHP 3.0 has a standard way of storing persistent resources (i.e.,
|
||||
resources that are kept in between hits). The first module to use
|
||||
this feature was the MySQL module, and mSQL followed it, so one can
|
||||
get the general impression of how a persistent resource should be
|
||||
used by reading mysql.c. The functions you should look at are:
|
||||
php3_mysql_do_connect()
|
||||
php3_mysql_connect()
|
||||
php3_mysql_pconnect()
|
||||
|
||||
The general idea of persistence modules is this:
|
||||
1. Code all of your module to work with the regular resource list
|
||||
mentioned in section (9).
|
||||
2. Code extra connect functions that check if the resource already
|
||||
exists in the persistent resource list. If it does, register it
|
||||
as in the regular resource list as a pointer to the persistent
|
||||
resource list (because of 1., the rest of the code
|
||||
should work immediately). If it doesn't, then create it, add it
|
||||
to the persistent resource list AND add a pointer to it from the
|
||||
regular resource list, so all of the code would work since it's
|
||||
in the regular resource list, but on the next connect, the
|
||||
resource would be found in the persistent resource list and be
|
||||
used without having to recreate it.
|
||||
You should register these resources with a different type (e.g.
|
||||
LE_MYSQL_LINK for non-persistent link and LE_MYSQL_PLINK for
|
||||
a persistent link).
|
||||
|
||||
If you read mysql.c, you'll notice that except for the more complex
|
||||
connect function, nothing in the rest of the module has to be changed.
|
||||
|
||||
The very same interface exists for the regular resource list and the
|
||||
persistent resource list, only 'list' is replaced with 'plist':
|
||||
|
||||
php3_plist_insert(ptr, type) returns the 'id' of the newly inserted resource
|
||||
php3_plist_delete(id) delete the resource with the specified id
|
||||
php3_plist_find(id,*type) returns the pointer of the resource with the specified id, updates 'type' to the resource's type
|
||||
|
||||
However, it's more than likely that these functions would prove
|
||||
to be useless for you when trying to implement a persistent module.
|
||||
Typically, one would want to use the fact that the persistent resource
|
||||
list is really a hash table. For instance, in the MySQL/mSQL modules,
|
||||
when there's a pconnect() call (persistent connect), the function
|
||||
builds a string out of the host/user/passwd that were passed to the
|
||||
function, and hashes the SQL link with this string as a key. The next
|
||||
time someone calls a pconnect() with the same host/user/passwd, the
|
||||
same key would be generated, and the function would find the SQL link
|
||||
in the persistent list.
|
||||
|
||||
Until further documented, you should look at mysql.c or msql.c to
|
||||
see how one should use the plist's hash table abilities.
|
||||
|
||||
One important thing to note: resources going into the persistent
|
||||
resource list must *NOT* be allocated with PHP's memory manager, i.e.,
|
||||
they should NOT be created with emalloc(), estrdup(), etc. Rather,
|
||||
one should use the regular malloc(), strdup(), etc. The reason for
|
||||
this is simple - at the end of the request (end of the hit), every
|
||||
memory chunk that was allocated using PHP's memory manager is deleted.
|
||||
Since the persistent list isn't supposed to be erased at the end
|
||||
of a request, one mustn't use PHP's memory manager for allocating
|
||||
resources that go to it.
|
||||
|
||||
Shutting down persistent resources:
|
||||
|
||||
When you register resource that's going to be in the persistent list,
|
||||
you should add destructors to it both in the non-persistent list
|
||||
and in the persistent list.
|
||||
The destructor in the non-persistent list destructor shouldn't do anything.
|
||||
The one in the persistent list destructor should properly free any
|
||||
resources obtained by that type (e.g. memory, SQL links, etc). Just like
|
||||
with the non-persistent resources, you *MUST* add destructors for every
|
||||
resource, even it requires no destructotion and the destructor would
|
||||
be empty.
|
||||
Remember, since emalloc() and friends aren't to be used in conjunction
|
||||
with the persistent list, you mustn't use efree() here either.
|
||||
|
||||
-------------------
|
||||
|
||||
11. Adding runtime configuration directives
|
||||
|
||||
Many of the features of PHP3 can be configured at runtime. These
|
||||
configuration directives can appear in either the designated php3.ini
|
||||
file, or in the case of the Apache module version in the Apache .conf
|
||||
files. The advantage of having them in the Apache .conf files is that
|
||||
they can be configured on a per-directory basis. This means that one
|
||||
directory may have a certain safemodeexecdir for example, while another
|
||||
directory may have another. This configuration granularity is especially
|
||||
handy when a server supports multiple virtual hosts.
|
||||
|
||||
The steps required to add a new directive:
|
||||
|
||||
1. Add directive to php3_ini_structure struct in mod_php4.h.
|
||||
|
||||
2. In main.c, edit the php3_module_startup function and add the
|
||||
appropriate cfg_get_string() or cfg_get_long() call.
|
||||
|
||||
3. Add the directive, restrictions and a comment to the php3_commands
|
||||
structure in mod_php4.c. Note the restrictions part. RSRC_CONF are
|
||||
directives that can only be present in the actual Apache .conf files.
|
||||
Any OR_OPTIONS directives can be present anywhere, include normal
|
||||
.htaccess files.
|
||||
|
||||
4. In either php3take1handler() or php3flaghandler() add the appropriate
|
||||
entry for your directive.
|
||||
|
||||
5. In the configuration section of the _php3_info() function in
|
||||
functions/info.c you need to add your new directive.
|
||||
|
||||
6. And last, you of course have to use your new directive somewhere.
|
||||
It will be addressable as php3_ini.directive
|
||||
@@ -1,37 +0,0 @@
|
||||
#!/bin/sh
|
||||
# $Id$
|
||||
|
||||
while test $# -gt 0; do
|
||||
if test "$1" = "--copy"; then
|
||||
automake_flags=--copy
|
||||
fi
|
||||
|
||||
if test "$1" = "--ZendEngine2"; then
|
||||
ZENDDIR=ZendEngine2
|
||||
echo "Using Zend Engine 2 code"
|
||||
fi
|
||||
|
||||
shift
|
||||
done
|
||||
|
||||
if test -z "$ZENDDIR"; then
|
||||
ZENDDIR=Zend
|
||||
echo "using default Zend directory"
|
||||
fi
|
||||
|
||||
## build.mk does not check aclocal exit status yet
|
||||
##
|
||||
#mv aclocal.m4 aclocal.m4.old 2>/dev/null
|
||||
#aclocal
|
||||
#if test "$?" != "0" -a "$am_prefix" != "$lt_prefix"; then
|
||||
# echo "buildconf: ERROR: aclocal failed, probably because automake and"
|
||||
# echo " libtool are installed with different prefixes;"
|
||||
# echo " automake is installed in $am_prefix, but libtool in $lt_prefix."
|
||||
# echo " Please re-install automake and/or libtool with a common prefix"
|
||||
# echo " and try again."
|
||||
# exit 1
|
||||
#fi
|
||||
|
||||
rm -f generated_lists
|
||||
|
||||
${MAKE:-make} -s -f build/build.mk AMFLAGS="$automake_flags" ZENDDIR="$ZENDDIR"
|
||||
Vendored
-1308
File diff suppressed because it is too large.
Load diff
Vendored
-1417
File diff suppressed because it is too large.
Load diff
-1315
File diff suppressed because it is too large.
Load diff
-103
@@ -1,103 +0,0 @@
|
||||
#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
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -1,55 +0,0 @@
|
||||
dnl
|
||||
dnl $Id$
|
||||
dnl
|
||||
|
||||
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,for 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
|
||||
if test "$PHP_PCRE_REGEX" = "yes"; then
|
||||
PHP_NEW_EXTENSION(pcre, pcrelib/maketables.c pcrelib/get.c pcrelib/study.c pcrelib/pcre.c php_pcre.c, $ext_shared,,-DSUPPORT_UTF8 -I@ext_srcdir@/pcrelib)
|
||||
PHP_ADD_BUILD_DIR($ext_builddir/pcrelib)
|
||||
AC_DEFINE(HAVE_BUNDLED_PCRE, 1, [ ])
|
||||
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
|
||||
|
||||
PHP_ADD_LIBRARY_WITH_PATH(pcre, $PCRE_LIBDIR, PCRE_SHARED_LIBADD)
|
||||
|
||||
AC_DEFINE(HAVE_PCRE, 1, [ ])
|
||||
PHP_NEW_EXTENSION(pcre, php_pcre.c, $ext_shared,,-DSUPPORT_UTF8 -I$PCRE_INCDIR)
|
||||
fi
|
||||
fi
|
||||
PHP_SUBST(PCRE_SHARED_LIBADD)
|
||||
|
||||
AC_CHECK_FUNC(memmove, [], [AC_DEFINE(USE_BCOPY, 1, [ ])])
|
||||
@@ -1,8 +0,0 @@
|
||||
|
||||
/*
|
||||
* Local variables:
|
||||
* tab-width: 4
|
||||
* c-basic-offset: 4
|
||||
* indent-tabs-mode: t
|
||||
* End:
|
||||
*/
|
||||
@@ -1,14 +0,0 @@
|
||||
#! /bin/sh
|
||||
|
||||
STD='make -f Makefile.frag LEX="flex -L" YACC="bison -y -l" srcdir=Zend builddir=Zend'
|
||||
|
||||
(eval "$STD Zend/zend_language_parser.c Zend/zend_language_scanner.c Zend/zend_ini_parser.c Zend/zend_ini_scanner.c")
|
||||
|
||||
set -x
|
||||
bison -d -y -l ext/standard/parsedate.y -o ext/standard/parsedate.c
|
||||
|
||||
for f in ext/standard/url_scanner_ex.c ext/standard/var_unserializer.c; do
|
||||
cp $f $f.orig
|
||||
grep -v '#line ' $f.orig > $f
|
||||
done
|
||||
|
||||
@@ -1,19 +0,0 @@
|
||||
/*
|
||||
+----------------------------------------------------------------------+
|
||||
| PHP Version 4 |
|
||||
+----------------------------------------------------------------------+
|
||||
| Copyright (c) 1997-2002 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: |
|
||||
+----------------------------------------------------------------------+
|
||||
|
||||
$Id$
|
||||
*/
|
||||
@@ -1,283 +0,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. |
|
||||
+----------------------------------------------------------------------+
|
||||
| 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:
|
||||
*/
|
||||
@@ -1,148 +0,0 @@
|
||||
#!/bin/sh
|
||||
#
|
||||
# Distribution generator for CVS based packages.
|
||||
# To work, this script needs a consistent tagging of all releases.
|
||||
# Each release of a package should have a tag of the form
|
||||
#
|
||||
# <package>_<version>
|
||||
#
|
||||
# where <package> is the package name and the CVS module
|
||||
# and <version> s the version number with underscores instead of dots.
|
||||
#
|
||||
# For example: cvs tag php_3_0a1
|
||||
#
|
||||
# The distribution ends up in a .tar.gz file that contains the distribution
|
||||
# in a directory called <package>-<version>. The distribution contains all
|
||||
# directories from the CVS module except the one called "nodist", but only
|
||||
# the files INSTALL, README and config* are included.
|
||||
#
|
||||
# Since you can no longer set the CVS password via an env variable, you
|
||||
# need to have previously done a cvs login for the server and user id
|
||||
# this script uses so it will have an entry in your ~/.cvspasswd file.
|
||||
#
|
||||
# Usage: makedist <package> <version>
|
||||
#
|
||||
# Written by Stig Bakken <ssb@guardian.no> 1997-05-28.
|
||||
#
|
||||
# $Id$
|
||||
#
|
||||
|
||||
if test "$#" != "2"; then
|
||||
echo "Usage: makedist <package> <version>" >&2
|
||||
exit 1
|
||||
fi
|
||||
|
||||
PKG=$1 ; shift
|
||||
VER=$1 ; shift
|
||||
|
||||
old_IFS="$IFS"
|
||||
IFS=.
|
||||
eval set `bison --version| grep 'GNU Bison' | cut -d ' ' -f 4 | sed -e 's/\./ /'`
|
||||
if test "${1}" = "1" -a "${2}" -lt "28"; then
|
||||
echo "You will need bison 1.28 if you want to regenerate the Zend parser (found ${1}.${2}).)"
|
||||
exit 10
|
||||
fi
|
||||
IFS="$old_IFS"
|
||||
|
||||
PHPROOT=:pserver:cvsread@cvs.php.net:/repository
|
||||
ZENDROOT=:pserver:cvsread@cvs.php.net:/repository
|
||||
PHPMOD=php4
|
||||
ZENDMOD=Zend
|
||||
TSRMMOD=TSRM
|
||||
LT_TARGETS='ltconfig ltmain.sh config.guess config.sub'
|
||||
|
||||
if echo '\c' | grep -s c >/dev/null 2>&1
|
||||
then
|
||||
ECHO_N="echo -n"
|
||||
ECHO_C=""
|
||||
else
|
||||
ECHO_N="echo"
|
||||
ECHO_C='\c'
|
||||
fi
|
||||
|
||||
MY_OLDPWD=`pwd`
|
||||
|
||||
# the destination .tar.gz file
|
||||
ARCHIVE=$MY_OLDPWD/$PKG-$VER.tar
|
||||
|
||||
# temporary directory used to check out files from CVS
|
||||
DIR=$PKG-$VER
|
||||
DIRPATH=$MY_OLDPWD/$DIR
|
||||
|
||||
if test -d "$DIRPATH"; then
|
||||
echo "The directory $DIR"
|
||||
echo "already exists, rename or remove it and run makedist again."
|
||||
exit 1
|
||||
fi
|
||||
|
||||
# version part of the CVS release tag
|
||||
CVSVER=`echo $VER | sed -e 's/[\.\-]/_/g'`
|
||||
|
||||
# CVS release tag
|
||||
CVSTAG=${PKG}_$CVSVER
|
||||
|
||||
if test ! -d $DIRPATH; then
|
||||
mkdir -p $DIRPATH || exit 2
|
||||
fi
|
||||
|
||||
#cd $DIRPATH || exit 3
|
||||
|
||||
# Export PHP
|
||||
$ECHO_N "makedist: exporting tag '$CVSTAG' from '$PHPMOD'...$ECHO_C"
|
||||
cvs -z 9 -d $PHPROOT -Q export -d $DIR -r $CVSTAG $PHPMOD || exit 4
|
||||
echo ""
|
||||
|
||||
# Export the other modules inside the PHP directory
|
||||
cd $DIR || exit 5
|
||||
|
||||
# Export Zend
|
||||
$ECHO_N "makedist: exporting tag '$CVSTAG' from '$ZENDMOD'...$ECHO_C"
|
||||
cvs -z 9 -d $ZENDROOT -Q export -r $CVSTAG $ZENDMOD || exit 4
|
||||
echo ""
|
||||
|
||||
# Export TSRM
|
||||
$ECHO_N "makedist: exporting tag '$CVSTAG' from '$TSRMMOD'...$ECHO_C"
|
||||
cvs -z 9 -d $ZENDROOT -Q export -r $CVSTAG $TSRMMOD || exit 4
|
||||
echo ""
|
||||
|
||||
# remove CVS stuff...
|
||||
find . \( \( -name CVS -type d \) -o -name .cvsignore \) -exec rm -rf {} \;
|
||||
|
||||
# The full ChangeLog is available separately from lxr.php.net
|
||||
rm ChangeLog*
|
||||
|
||||
# hide away our own versions of libtool-generated files
|
||||
for i in $LT_TARGETS; do
|
||||
if test -f "$i"; then
|
||||
mv $i $i.bak
|
||||
cp $i.bak $i
|
||||
fi
|
||||
done
|
||||
|
||||
# generate some files so people don't need bison, flex and autoconf
|
||||
# to install
|
||||
set -x
|
||||
./buildconf --copy
|
||||
|
||||
# remove buildmk.stamp. Otherwise, buildcheck.sh might not be run,
|
||||
# when a user runs buildconf in the distribution.
|
||||
rm -f buildmk.stamp
|
||||
|
||||
./genfiles
|
||||
|
||||
# now restore our versions of libtool-generated files
|
||||
for i in $LT_TARGETS; do
|
||||
test -f "$i" && mv $i.bak $i
|
||||
done
|
||||
|
||||
cd $MY_OLDPWD
|
||||
$ECHO_N "makedist: making gzipped tar archive...$ECHO_C"
|
||||
tar cf $ARCHIVE $PKG-$VER || exit 8
|
||||
gzip -9 $ARCHIVE || exit 9
|
||||
echo ""
|
||||
|
||||
$ECHO_N "makedist: cleaning up...$ECHO_C"
|
||||
rm -rf $DIRPATH || exit 10
|
||||
echo ""
|
||||
|
||||
exit 0
|
||||
@@ -1,149 +0,0 @@
|
||||
#!/bin/sh
|
||||
#
|
||||
# Distribution generator for CVS based packages.
|
||||
# To work, this script needs a consistent tagging of all releases.
|
||||
# Each release of a package should have a tag of the form
|
||||
#
|
||||
# <package>_<version>
|
||||
#
|
||||
# where <package> is the package name and the CVS module
|
||||
# and <version> s the version number with underscores instead of dots.
|
||||
#
|
||||
# For example: cvs tag php_3_0a1
|
||||
#
|
||||
# The distribution ends up in a .tar.gz file that contains the distribution
|
||||
# in a directory called <package>-<version>. The distribution contains all
|
||||
# directories from the CVS module except the one called "nodist", but only
|
||||
# the files INSTALL, README and config* are included.
|
||||
#
|
||||
# Since you can no longer set the CVS password via an env variable, you
|
||||
# need to have previously done a cvs login for the server and user id
|
||||
# this script uses so it will have an entry in your ~/.cvspasswd file.
|
||||
#
|
||||
# Usage: makedist <package> <version>
|
||||
#
|
||||
# Written by Stig Bakken <ssb@guardian.no> 1997-05-28.
|
||||
#
|
||||
# $Id$
|
||||
#
|
||||
|
||||
if test "$#" != "2"; then
|
||||
echo "Usage: makedist <package> <version>" >&2
|
||||
exit 1
|
||||
fi
|
||||
|
||||
PKG=$1 ; shift
|
||||
VER=$1 ; shift
|
||||
|
||||
old_IFS="$IFS"
|
||||
IFS=.
|
||||
eval set `bison --version| grep 'GNU Bison' | cut -d ' ' -f 4 | sed -e 's/\./ /'`
|
||||
if test "${1}" = "1" -a "${2}" -lt "28"; then
|
||||
echo "You will need bison 1.28 if you want to regenerate the Zend parser (found ${1}.${2}).)"
|
||||
exit 10
|
||||
fi
|
||||
IFS="$old_IFS"
|
||||
|
||||
PHPROOT=:pserver:cvsread@cvs.php.net:/repository
|
||||
ZENDROOT=:pserver:cvsread@cvs.php.net:/repository
|
||||
PHPMOD=php4
|
||||
ZENDMOD=ZendEngine2
|
||||
TSRMMOD=TSRM
|
||||
LT_TARGETS='ltconfig ltmain.sh config.guess config.sub'
|
||||
|
||||
if echo '\c' | grep -s c >/dev/null 2>&1
|
||||
then
|
||||
ECHO_N="echo -n"
|
||||
ECHO_C=""
|
||||
else
|
||||
ECHO_N="echo"
|
||||
ECHO_C='\c'
|
||||
fi
|
||||
|
||||
MY_OLDPWD=`pwd`
|
||||
|
||||
# the destination .tar.gz file
|
||||
ARCHIVE=$MY_OLDPWD/$PKG-$VER.tar
|
||||
|
||||
# temporary directory used to check out files from CVS
|
||||
DIR=$PKG-$VER
|
||||
DIRPATH=$MY_OLDPWD/$DIR
|
||||
|
||||
if test -d "$DIRPATH"; then
|
||||
echo "The directory $DIR"
|
||||
echo "already exists, rename or remove it and run makedist again."
|
||||
exit 1
|
||||
fi
|
||||
|
||||
# version part of the CVS release tag
|
||||
CVSVER=`echo $VER | sed -e 's/[\.\-]/_/g'`
|
||||
|
||||
# CVS release tag
|
||||
CVSTAG=${PKG}_$CVSVER
|
||||
|
||||
if test ! -d $DIRPATH; then
|
||||
mkdir -p $DIRPATH || exit 2
|
||||
fi
|
||||
|
||||
#cd $DIRPATH || exit 3
|
||||
|
||||
# Export PHP
|
||||
$ECHO_N "makedist: exporting tag '$CVSTAG' from '$PHPMOD'...$ECHO_C"
|
||||
cvs -z 9 -d $PHPROOT -Q export -d $DIR -r $CVSTAG $PHPMOD || exit 4
|
||||
echo ""
|
||||
|
||||
# Export the other modules inside the PHP directory
|
||||
cd $DIR || exit 5
|
||||
|
||||
# Export Zend
|
||||
$ECHO_N "makedist: exporting tag '$CVSTAG' from '$ZENDMOD'...$ECHO_C"
|
||||
cvs -z 9 -d $ZENDROOT -Q export -r $CVSTAG $ZENDMOD || exit 4
|
||||
mv ZendEngine2 Zend
|
||||
echo ""
|
||||
|
||||
# Export TSRM
|
||||
#$ECHO_N "makedist: exporting tag '$CVSTAG' from '$TSRMMOD'...$ECHO_C"
|
||||
#cvs -z 9 -d $ZENDROOT -Q export -r $CVSTAG $TSRMMOD || exit 4
|
||||
#echo ""
|
||||
|
||||
# remove CVS stuff...
|
||||
find . \( \( -name CVS -type d \) -o -name .cvsignore \) -exec rm -rf {} \;
|
||||
|
||||
# The full ChangeLog is available separately from lxr.php.net
|
||||
rm ChangeLog*
|
||||
|
||||
# hide away our own versions of libtool-generated files
|
||||
for i in $LT_TARGETS; do
|
||||
if test -f "$i"; then
|
||||
mv $i $i.bak
|
||||
cp $i.bak $i
|
||||
fi
|
||||
done
|
||||
|
||||
# generate some files so people don't need bison, flex and autoconf
|
||||
# to install
|
||||
set -x
|
||||
./buildconf --copy
|
||||
|
||||
# remove buildmk.stamp. Otherwise, buildcheck.sh might not be run,
|
||||
# when a user runs buildconf in the distribution.
|
||||
rm -f buildmk.stamp
|
||||
|
||||
./genfiles
|
||||
|
||||
# now restore our versions of libtool-generated files
|
||||
for i in $LT_TARGETS; do
|
||||
test -f "$i" && mv $i.bak $i
|
||||
done
|
||||
|
||||
cd $MY_OLDPWD
|
||||
$ECHO_N "makedist: making gzipped tar archive...$ECHO_C"
|
||||
tar cf $ARCHIVE $PKG-$VER || exit 8
|
||||
gzip -9 $ARCHIVE || exit 9
|
||||
echo ""
|
||||
|
||||
$ECHO_N "makedist: cleaning up...$ECHO_C"
|
||||
rm -rf $DIRPATH || exit 10
|
||||
echo ""
|
||||
|
||||
exit 0
|
||||
@@ -1,156 +0,0 @@
|
||||
#! /bin/sh
|
||||
|
||||
# Based slightly on an original by John H Terpstra but not much left of his.
|
||||
# S Liddicott 1999 sam@campbellsci.co.uk
|
||||
|
||||
PREFIX="php"
|
||||
TARDIR="`basename \`pwd\``"
|
||||
RELEASE=${1:-1}
|
||||
VERSION=${2:-`echo $TARDIR | sed "s/$PREFIX-//g"`}
|
||||
|
||||
if [ "$VERSION" = "" ]
|
||||
then cat <<"EOH"
|
||||
$PREFIX source needs to be installed in a folder that contains the version
|
||||
number, e.g. ${PREFIX}4 or ${PREFIX}4b2
|
||||
EOH
|
||||
fi
|
||||
|
||||
echo "Usage:"
|
||||
echo "$0 <release>"
|
||||
echo
|
||||
echo "e.g.:"
|
||||
echo "$0 2"
|
||||
echo -n "Building RPM version $VERSION, release: $RELEASE "
|
||||
sleep 1 ; echo -n . ; sleep 1 ; echo -n . ; sleep 1 ; echo -n .
|
||||
echo
|
||||
|
||||
TAR=php-$VERSION.tar.gz
|
||||
SPEC=php-$VERSION.spec
|
||||
|
||||
# write out the .spec file
|
||||
sed -e "s/PVERSION/$VERSION/g" \
|
||||
-e "s/PRELEASE/$RELEASE/g" \
|
||||
-e "s/TARDIR/$TARDIR/g" \
|
||||
> $SPEC <<'EOF'
|
||||
Summary: PHP 4 - A powerful scripting language
|
||||
Name: mod_php4
|
||||
Version: PVERSION
|
||||
Release: PRELEASE
|
||||
Group: Networking/Daemons
|
||||
Source0: http://www.php.net/distributions/php-%{PACKAGE_VERSION}.tar.gz
|
||||
Copyright: GPL
|
||||
BuildRoot: /tmp/php4-root
|
||||
Requires: webserver
|
||||
|
||||
%description
|
||||
PHP4 is a powerful apache module that adds scripting and database connection
|
||||
capabilities to the apache server. This version includes the "php" binary
|
||||
for suExec and stand alone php scripts too.
|
||||
|
||||
%prep
|
||||
%setup -q -n TARDIR
|
||||
#mkdir manual; cd manual && tar xzf $RPM_SOURCE_DIR/php3-manual.tar.gz
|
||||
chown -R root.root .
|
||||
./buildconf
|
||||
|
||||
%build
|
||||
# first the standalone (why can't you build both at once?)
|
||||
# need to run this under sh or it breaks
|
||||
|
||||
sh ./configure --prefix=/usr \
|
||||
--with-config-file-path=/usr/lib \
|
||||
--enable-force-cgi-redirect \
|
||||
--enable-safe-mode \
|
||||
--with-exec-dir=/usr/bin \
|
||||
--with-mysql=/usr \
|
||||
--with-pdflib=/usr \
|
||||
--with-zlib=/usr \
|
||||
--enable-xml \
|
||||
--enable-wddx
|
||||
|
||||
make
|
||||
mv php php.keepme
|
||||
|
||||
# then the apache module
|
||||
rm config.cache
|
||||
sh ./configure --prefix=/usr \
|
||||
--with-apxs=/usr/sbin/apxs \
|
||||
--enable-versioning \
|
||||
--with-config-file-path=/usr/lib \
|
||||
--enable-safe-mode \
|
||||
--with-exec-dir=/usr/bin \
|
||||
--with-mysql=/usr \
|
||||
--with-pdflib=/usr \
|
||||
--with-zlib=/usr \
|
||||
--enable-xml \
|
||||
--enable-wddx
|
||||
|
||||
make clean
|
||||
make
|
||||
# restore cgi version
|
||||
mv php.keepme php
|
||||
|
||||
%install
|
||||
rm -rf $RPM_BUILD_ROOT
|
||||
mkdir -p $RPM_BUILD_ROOT/usr/lib/apache
|
||||
install -m 755 .libs/libphp4.so $RPM_BUILD_ROOT/usr/lib/apache
|
||||
mkdir -p $RPM_BUILD_ROOT/usr/bin
|
||||
install -m 755 php $RPM_BUILD_ROOT/usr/bin
|
||||
|
||||
%clean
|
||||
rm -rf $RPM_BUILD_ROOT
|
||||
|
||||
%changelog
|
||||
* Mon Mar 04 2002 Arjen Lentz <agl@bitbike.com>
|
||||
- Fix path and remove --with-imap due to conflicts with kerberos.
|
||||
|
||||
* Fri Jun 29 2001 Jani Taskinen <sniper@iki.fi>
|
||||
- Removed some useless configure options. Made the tar names correct.
|
||||
|
||||
* Sun Apr 30 2000 Joey Smith <joey@samaritan.com>
|
||||
- Small fix: Description still referred to package as PHP3.
|
||||
|
||||
* Wed Jul 21 1999 Sam Liddicott <sam@campbellsci.co.uk>
|
||||
- added php4b1 and modified cgi building rules so it doesn't break module
|
||||
|
||||
* Wed Mar 17 1999 Sam Liddicott <sam@campbellsci.co.uk>
|
||||
- Stuffed in 3.0.7 source tar and added "php" as a build destination
|
||||
|
||||
* Mon Oct 12 1998 Cristian Gafton <gafton@redhat.com>
|
||||
- rebuild for apache 1.3.3
|
||||
|
||||
* Thu Oct 08 1998 Preston Brown <pbrown@redhat.com>
|
||||
- updated to 3.0.5, fixes nasty bugs in 3.0.4.
|
||||
|
||||
* Sun Sep 27 1998 Cristian Gafton <gafton@redhat.com>
|
||||
- updated to 3.0.4 and recompiled for apache 1.3.2
|
||||
|
||||
* Thu Sep 03 1998 Preston Brown <pbrown@redhat.com>
|
||||
- improvements; builds with apache-devel package installed.
|
||||
|
||||
* Tue Sep 01 1998 Preston Brown <pbrown@redhat.com>
|
||||
- Made initial cut for PHP3.
|
||||
|
||||
%files
|
||||
/usr/lib/apache/libphp4.so
|
||||
/usr/bin/php
|
||||
%doc TODO CODING_STANDARDS CREDITS ChangeLog LICENSE BUGS examples
|
||||
%doc manual/*
|
||||
EOF
|
||||
|
||||
RPMDIR=/usr/src/redhat/RPMS
|
||||
SPECDIR=/usr/src/redhat/SPECS
|
||||
SRCDIR=/usr/src/redhat/SOURCES
|
||||
|
||||
(
|
||||
make clean
|
||||
find . -name config.cache -exec rm -f '{}'
|
||||
cd ..
|
||||
tar czvf ${SRCDIR}/${TAR} $TARDIR )
|
||||
|
||||
cp -a $SPEC $SPECDIR/${SPEC}
|
||||
#cp -a *.patch $SRCDIR
|
||||
cd $SRCDIR
|
||||
chown -R root.root ${TAR}
|
||||
cd $SPECDIR
|
||||
rpm -ba -v ${SPEC}
|
||||
-948
@@ -1,948 +0,0 @@
|
||||
[PHP]
|
||||
|
||||
;;;;;;;;;;;
|
||||
; WARNING ;
|
||||
;;;;;;;;;;;
|
||||
; This is the default settings file for new PHP installations.
|
||||
; By default, PHP installs itself with a configuration suitable for
|
||||
; development purposes, and *NOT* for production purposes.
|
||||
; For several security-oriented considerations that should be taken
|
||||
; before going online with your site, please consult php.ini-recommended
|
||||
; and http://php.net/manual/en/security.php.
|
||||
|
||||
|
||||
;;;;;;;;;;;;;;;;;;;
|
||||
; About this file ;
|
||||
;;;;;;;;;;;;;;;;;;;
|
||||
; This file controls many aspects of PHP's behavior. In order for PHP to
|
||||
; read it, it must be named 'php.ini'. PHP looks for it in the current
|
||||
; working directory, in the path designated by the environment variable
|
||||
; PHPRC, and in the path that was defined in compile time (in that order).
|
||||
; Under Windows, the compile-time path is the Windows directory. The
|
||||
; path in which the php.ini file is looked for can be overridden using
|
||||
; the -c argument in command line mode.
|
||||
;
|
||||
; The syntax of the file is extremely simple. Whitespace and Lines
|
||||
; beginning with a semicolon are silently ignored (as you probably guessed).
|
||||
; Section headers (e.g. [Foo]) are also silently ignored, even though
|
||||
; they might mean something in the future.
|
||||
;
|
||||
; Directives are specified using the following syntax:
|
||||
; directive = value
|
||||
; Directive names are *case sensitive* - foo=bar is different from FOO=bar.
|
||||
;
|
||||
; The value can be a string, a number, a PHP constant (e.g. E_ALL or M_PI), one
|
||||
; of the INI constants (On, Off, True, False, Yes, No and None) or an expression
|
||||
; (e.g. E_ALL & ~E_NOTICE), or a quoted string ("foo").
|
||||
;
|
||||
; Expressions in the INI file are limited to bitwise operators and parentheses:
|
||||
; | bitwise OR
|
||||
; & bitwise AND
|
||||
; ~ bitwise NOT
|
||||
; ! boolean NOT
|
||||
;
|
||||
; Boolean flags can be turned on using the values 1, On, True or Yes.
|
||||
; They can be turned off using the values 0, Off, False or No.
|
||||
;
|
||||
; An empty string can be denoted by simply not writing anything after the equal
|
||||
; sign, or by using the None keyword:
|
||||
;
|
||||
; foo = ; sets foo to an empty string
|
||||
; foo = none ; sets foo to an empty string
|
||||
; foo = "none" ; sets foo to the string 'none'
|
||||
;
|
||||
; If you use constants in your value, and these constants belong to a
|
||||
; dynamically loaded extension (either a PHP extension or a Zend extension),
|
||||
; you may only use these constants *after* the line that loads the extension.
|
||||
;
|
||||
; All the values in the php.ini-dist file correspond to the builtin
|
||||
; defaults (that is, if no php.ini is used, or if you delete these lines,
|
||||
; the builtin defaults will be identical).
|
||||
|
||||
|
||||
;;;;;;;;;;;;;;;;;;;;
|
||||
; Language Options ;
|
||||
;;;;;;;;;;;;;;;;;;;;
|
||||
|
||||
; Enable the PHP scripting language engine under Apache.
|
||||
engine = On
|
||||
|
||||
; Allow the <? tag. Otherwise, only <?php and <script> tags are recognized.
|
||||
short_open_tag = On
|
||||
|
||||
; Allow ASP-style <% %> tags.
|
||||
asp_tags = Off
|
||||
|
||||
; The number of significant digits displayed in floating point numbers.
|
||||
precision = 12
|
||||
|
||||
; Enforce year 2000 compliance (will cause problems with non-compliant browsers)
|
||||
y2k_compliance = Off
|
||||
|
||||
; Output buffering allows you to send header lines (including cookies) even
|
||||
; after you send body content, at the price of slowing PHP's output layer a
|
||||
; bit. You can enable output buffering during runtime by calling the output
|
||||
; buffering functions. You can also enable output buffering for all files by
|
||||
; setting this directive to On. If you wish to limit the size of the buffer
|
||||
; to a certain size - you can use a maximum number of bytes instead of 'On', as
|
||||
; a value for this directive (e.g., output_buffering=4096).
|
||||
output_buffering = Off
|
||||
|
||||
; You can redirect all of the output of your scripts to a function. For
|
||||
; example, if you set output_handler to "ob_gzhandler", output will be
|
||||
; transparently compressed for browsers that support gzip or deflate encoding.
|
||||
; Setting an output handler automatically turns on output buffering.
|
||||
output_handler =
|
||||
|
||||
; The unserialize callback function will called (with the undefind class'
|
||||
; name as parameter), if the unserializer finds an undefined class
|
||||
; which should be instanciated.
|
||||
; A warning appears if the specified function is not defined, or if the
|
||||
; function doesn't include/implement the missing class.
|
||||
; So only set this entry, if you really want to implement such a
|
||||
; callback-function.
|
||||
unserialize_callback_func=
|
||||
|
||||
; Transparent output compression using the zlib library
|
||||
; Valid values for this option are 'off', 'on', or a specific buffer size
|
||||
; to be used for compression (default is 4KB)
|
||||
;
|
||||
; Note: output_handler must be empty if this is set 'On' !!!!
|
||||
;
|
||||
zlib.output_compression = Off
|
||||
|
||||
; Implicit flush tells PHP to tell the output layer to flush itself
|
||||
; automatically after every output block. This is equivalent to calling the
|
||||
; PHP function flush() after each and every call to print() or echo() and each
|
||||
; and every HTML block. Turning this option on has serious performance
|
||||
; implications and is generally recommended for debugging purposes only.
|
||||
implicit_flush = Off
|
||||
|
||||
; Whether to enable the ability to force arguments to be passed by reference
|
||||
; at function call time. This method is deprecated and is likely to be
|
||||
; unsupported in future versions of PHP/Zend. The encouraged method of
|
||||
; specifying which arguments should be passed by reference is in the function
|
||||
; declaration. You're encouraged to try and turn this option Off and make
|
||||
; sure your scripts work properly with it in order to ensure they will work
|
||||
; with future versions of the language (you will receive a warning each time
|
||||
; you use this feature, and the argument will be passed by value instead of by
|
||||
; reference).
|
||||
allow_call_time_pass_reference = On
|
||||
|
||||
; Safe Mode
|
||||
;
|
||||
safe_mode = Off
|
||||
|
||||
; By default, Safe Mode does a UID compare check when
|
||||
; opening files. If you want to relax this to a GID compare,
|
||||
; then turn on safe_mode_gid.
|
||||
safe_mode_gid = Off
|
||||
|
||||
; When safe_mode is on, UID/GID checks are bypassed when
|
||||
; including files from this directory and its subdirectories.
|
||||
; (directory must also be in include_path or full path must
|
||||
; be used when including)
|
||||
safe_mode_include_dir =
|
||||
|
||||
; When safe_mode is on, only executables located in the safe_mode_exec_dir
|
||||
; will be allowed to be executed via the exec family of functions.
|
||||
safe_mode_exec_dir =
|
||||
|
||||
; open_basedir, if set, limits all file operations to the defined directory
|
||||
; and below. This directive makes most sense if used in a per-directory
|
||||
; or per-virtualhost web server configuration file.
|
||||
;
|
||||
;open_basedir =
|
||||
|
||||
; Setting certain environment variables may be a potential security breach.
|
||||
; This directive contains a comma-delimited list of prefixes. In Safe Mode,
|
||||
; the user may only alter environment variables whose names begin with the
|
||||
; prefixes supplied here. By default, users will only be able to set
|
||||
; environment variables that begin with PHP_ (e.g. PHP_FOO=BAR).
|
||||
;
|
||||
; Note: If this directive is empty, PHP will let the user modify ANY
|
||||
; environment variable!
|
||||
safe_mode_allowed_env_vars = PHP_
|
||||
|
||||
; This directive contains a comma-delimited list of environment variables that
|
||||
; the end user won't be able to change using putenv(). These variables will be
|
||||
; protected even if safe_mode_allowed_env_vars is set to allow to change them.
|
||||
safe_mode_protected_env_vars = LD_LIBRARY_PATH
|
||||
|
||||
; This directive allows you to disable certain functions for security reasons.
|
||||
; It receives a comma-delimited list of function names. This directive is
|
||||
; *NOT* affected by whether Safe Mode is turned On or Off.
|
||||
disable_functions =
|
||||
|
||||
; Colors for Syntax Highlighting mode. Anything that's acceptable in
|
||||
; <font color="??????"> would work.
|
||||
highlight.string = #CC0000
|
||||
highlight.comment = #FF9900
|
||||
highlight.keyword = #006600
|
||||
highlight.bg = #FFFFFF
|
||||
highlight.default = #0000CC
|
||||
highlight.html = #000000
|
||||
|
||||
|
||||
;
|
||||
; Misc
|
||||
;
|
||||
; Decides whether PHP may expose the fact that it is installed on the server
|
||||
; (e.g. by adding its signature to the Web server header). It is no security
|
||||
; threat in any way, but it makes it possible to determine whether you use PHP
|
||||
; on your server or not.
|
||||
expose_php = On
|
||||
|
||||
|
||||
;;;;;;;;;;;;;;;;;;;
|
||||
; Resource Limits ;
|
||||
;;;;;;;;;;;;;;;;;;;
|
||||
|
||||
max_execution_time = 30 ; Maximum execution time of each script, in seconds
|
||||
memory_limit = 8M ; Maximum amount of memory a script may consume (8MB)
|
||||
|
||||
|
||||
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
||||
; Error handling and logging ;
|
||||
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
||||
|
||||
; error_reporting is a bit-field. Or each number up to get desired error
|
||||
; reporting level
|
||||
; E_ALL - All errors and warnings
|
||||
; E_ERROR - fatal run-time errors
|
||||
; E_WARNING - run-time warnings (non-fatal errors)
|
||||
; E_PARSE - compile-time parse errors
|
||||
; E_NOTICE - run-time notices (these are warnings which often result
|
||||
; from a bug in your code, but it's possible that it was
|
||||
; intentional (e.g., using an uninitialized variable and
|
||||
; relying on the fact it's automatically initialized to an
|
||||
; empty string)
|
||||
; E_CORE_ERROR - fatal errors that occur during PHP's initial startup
|
||||
; E_CORE_WARNING - warnings (non-fatal errors) that occur during PHP's
|
||||
; initial startup
|
||||
; E_COMPILE_ERROR - fatal compile-time errors
|
||||
; E_COMPILE_WARNING - compile-time warnings (non-fatal errors)
|
||||
; E_USER_ERROR - user-generated error message
|
||||
; E_USER_WARNING - user-generated warning message
|
||||
; E_USER_NOTICE - user-generated notice message
|
||||
;
|
||||
; Examples:
|
||||
;
|
||||
; - Show all errors, except for notices
|
||||
;
|
||||
;error_reporting = E_ALL & ~E_NOTICE
|
||||
;
|
||||
; - Show only errors
|
||||
;
|
||||
;error_reporting = E_COMPILE_ERROR|E_ERROR|E_CORE_ERROR
|
||||
;
|
||||
; - Show all errors except for notices
|
||||
;
|
||||
error_reporting = E_ALL & ~E_NOTICE
|
||||
|
||||
; Print out errors (as a part of the output). For production web sites,
|
||||
; you're strongly encouraged to turn this feature off, and use error logging
|
||||
; instead (see below). Keeping display_errors enabled on a production web site
|
||||
; may reveal security information to end users, such as file paths on your Web
|
||||
; server, your database schema or other information.
|
||||
display_errors = On
|
||||
|
||||
; Even when display_errors is on, errors that occur during PHP's startup
|
||||
; sequence are not displayed. It's strongly recommended to keep
|
||||
; display_startup_errors off, except for when debugging.
|
||||
display_startup_errors = Off
|
||||
|
||||
; Log errors into a log file (server-specific log, stderr, or error_log (below))
|
||||
; As stated above, you're strongly advised to use error logging in place of
|
||||
; error displaying on production web sites.
|
||||
log_errors = Off
|
||||
|
||||
; Set maximum length of log_errors. In error_log information about the source is
|
||||
; added. The default is 1024 and 0 allows to not apply any maximum length at all.
|
||||
log_errors_max_len = 1024
|
||||
|
||||
; Do not log repeated messages. Repeated errors must occur in same file on same
|
||||
; line until ignore_repeated_source is set true.
|
||||
ignore_repeated_errors = Off
|
||||
|
||||
; Ignore source of message when ignoring repeated messages. When this setting
|
||||
; is On you will not log errors with repeated messages from different files or
|
||||
; sourcelines.
|
||||
ignore_repeated_source = Off
|
||||
|
||||
; If this parameter is set to Off, then memory leaks will not be shown (on
|
||||
; stdout or in the log). This has only effect in a debug compile, and if
|
||||
; error reporting includes E_WARNING in the allowed list
|
||||
report_memleaks = On
|
||||
|
||||
; Store the last error/warning message in $php_errormsg (boolean).
|
||||
track_errors = Off
|
||||
|
||||
; Disable the inclusion of HTML tags in error messages.
|
||||
;html_errors = Off
|
||||
|
||||
; String to output before an error message.
|
||||
;error_prepend_string = "<font color=ff0000>"
|
||||
|
||||
; String to output after an error message.
|
||||
;error_append_string = "</font>"
|
||||
|
||||
; Log errors to specified file.
|
||||
;error_log = filename
|
||||
|
||||
; Log errors to syslog (Event Log on NT, not valid in Windows 95).
|
||||
;error_log = syslog
|
||||
|
||||
; Warn if the + operator is used with strings.
|
||||
warn_plus_overloading = Off
|
||||
|
||||
|
||||
;;;;;;;;;;;;;;;;;
|
||||
; Data Handling ;
|
||||
;;;;;;;;;;;;;;;;;
|
||||
;
|
||||
; Note - track_vars is ALWAYS enabled as of PHP 4.0.3
|
||||
|
||||
; The separator used in PHP generated URLs to separate arguments.
|
||||
; Default is "&".
|
||||
;arg_separator.output = "&"
|
||||
|
||||
; List of separator(s) used by PHP to parse input URLs into variables.
|
||||
; Default is "&".
|
||||
; NOTE: Every character in this directive is considered as separator!
|
||||
;arg_separator.input = ";&"
|
||||
|
||||
; This directive describes the order in which PHP registers GET, POST, Cookie,
|
||||
; Environment and Built-in variables (G, P, C, E & S respectively, often
|
||||
; referred to as EGPCS or GPC). Registration is done from left to right, newer
|
||||
; values override older values.
|
||||
variables_order = "EGPCS"
|
||||
|
||||
; Whether or not to register the EGPCS variables as global variables. You may
|
||||
; want to turn this off if you don't want to clutter your scripts' global scope
|
||||
; with user data. This makes most sense when coupled with track_vars - in which
|
||||
; case you can access all of the GPC variables through the $HTTP_*_VARS[],
|
||||
; variables.
|
||||
;
|
||||
; You should do your best to write your scripts so that they do not require
|
||||
; register_globals to be on; Using form variables as globals can easily lead
|
||||
; to possible security problems, if the code is not very well thought of.
|
||||
register_globals = Off
|
||||
|
||||
; This directive tells PHP whether to declare the argv&argc variables (that
|
||||
; would contain the GET information). If you don't use these variables, you
|
||||
; should turn it off for increased performance.
|
||||
register_argc_argv = On
|
||||
|
||||
; Maximum size of POST data that PHP will accept.
|
||||
post_max_size = 8M
|
||||
|
||||
; This directive is deprecated. Use variables_order instead.
|
||||
gpc_order = "GPC"
|
||||
|
||||
; Magic quotes
|
||||
;
|
||||
|
||||
; Magic quotes for incoming GET/POST/Cookie data.
|
||||
magic_quotes_gpc = On
|
||||
|
||||
; Magic quotes for runtime-generated data, e.g. data from SQL, from exec(), etc.
|
||||
magic_quotes_runtime = Off
|
||||
|
||||
; Use Sybase-style magic quotes (escape ' with '' instead of \').
|
||||
magic_quotes_sybase = Off
|
||||
|
||||
; Automatically add files before or after any PHP document.
|
||||
auto_prepend_file =
|
||||
auto_append_file =
|
||||
|
||||
; As of 4.0b4, PHP always outputs a character encoding by default in
|
||||
; the Content-type: header. To disable sending of the charset, simply
|
||||
; set it to be empty.
|
||||
;
|
||||
; PHP's built-in default is text/html
|
||||
default_mimetype = "text/html"
|
||||
;default_charset = "iso-8859-1"
|
||||
|
||||
; Always populate the $HTTP_RAW_POST_DATA variable.
|
||||
;always_populate_raw_post_data = On
|
||||
|
||||
;;;;;;;;;;;;;;;;;;;;;;;;;
|
||||
; Paths and Directories ;
|
||||
;;;;;;;;;;;;;;;;;;;;;;;;;
|
||||
|
||||
; UNIX: "/path1:/path2"
|
||||
;include_path = ".:/php/includes"
|
||||
;
|
||||
; Windows: "\path1;\path2"
|
||||
;include_path = ".;c:\php\includes"
|
||||
|
||||
; The root of the PHP pages, used only if nonempty.
|
||||
; if PHP was not compiled with FORCE_REDIRECT, you SHOULD set doc_root
|
||||
; if you are running php as a CGI under any web server (other than IIS)
|
||||
; see documentation for security issues. The alternate is to use the
|
||||
; cgi.force_redirect configuration below
|
||||
doc_root =
|
||||
|
||||
; The directory under which PHP opens the script using /~username used only
|
||||
; if nonempty.
|
||||
user_dir =
|
||||
|
||||
; Directory in which the loadable extensions (modules) reside.
|
||||
extension_dir = ./
|
||||
|
||||
; Whether or not to enable the dl() function. The dl() function does NOT work
|
||||
; properly in multithreaded servers, such as IIS or Zeus, and is automatically
|
||||
; disabled on them.
|
||||
enable_dl = On
|
||||
|
||||
; cgi.force_redirect is necessary to provide security running PHP as a CGI under
|
||||
; most web servers. Left undefined, PHP turns this on by default. You can
|
||||
; turn it off here AT YOUR OWN RISK
|
||||
; **You CAN safely turn this off for IIS, in fact, you MUST.**
|
||||
; cgi.force_redirect = 1
|
||||
|
||||
; if cgi.force_redirect is turned on, and you are not running under Apache or Netscape
|
||||
; (iPlanet) web servers, you MAY need to set an environment variable name that PHP
|
||||
; will look for to know it is OK to continue execution. Setting this variable MAY
|
||||
; cause security issues, KNOW WHAT YOU ARE DOING FIRST.
|
||||
; cgi.redirect_status_env = ;
|
||||
|
||||
; FastCGI under IIS (on WINNT based OS) supports the ability to impersonate
|
||||
; security tokens of the calling client. This allows IIS to define the
|
||||
; security context that the request runs under. mod_fastcgi under Apache
|
||||
; does not currently support this feature (03/17/2002)
|
||||
; Set to 1 if running under IIS. Default is zero.
|
||||
; fastcgi.impersonate = 1;
|
||||
|
||||
;;;;;;;;;;;;;;;;
|
||||
; File Uploads ;
|
||||
;;;;;;;;;;;;;;;;
|
||||
|
||||
; Whether to allow HTTP file uploads.
|
||||
file_uploads = On
|
||||
|
||||
; Temporary directory for HTTP uploaded files (will use system default if not
|
||||
; specified).
|
||||
;upload_tmp_dir =
|
||||
|
||||
; Maximum allowed size for uploaded files.
|
||||
upload_max_filesize = 2M
|
||||
|
||||
|
||||
;;;;;;;;;;;;;;;;;;
|
||||
; Fopen wrappers ;
|
||||
;;;;;;;;;;;;;;;;;;
|
||||
|
||||
; Whether to allow the treatment of URLs (like http:// or ftp://) as files.
|
||||
allow_url_fopen = On
|
||||
|
||||
; Define the anonymous ftp password (your email address)
|
||||
;from="john@doe.com"
|
||||
|
||||
|
||||
;;;;;;;;;;;;;;;;;;;;;;
|
||||
; Dynamic Extensions ;
|
||||
;;;;;;;;;;;;;;;;;;;;;;
|
||||
;
|
||||
; If you wish to have an extension loaded automatically, use the following
|
||||
; syntax:
|
||||
;
|
||||
; extension=modulename.extension
|
||||
;
|
||||
; For example, on Windows:
|
||||
;
|
||||
; extension=msql.dll
|
||||
;
|
||||
; ... or under UNIX:
|
||||
;
|
||||
; extension=msql.so
|
||||
;
|
||||
; Note that it should be the name of the module only; no directory information
|
||||
; needs to go here. Specify the location of the extension with the
|
||||
; extension_dir directive above.
|
||||
|
||||
|
||||
;Windows Extensions
|
||||
;Note that MySQL and ODBC support is now built in, so no dll is needed for it.
|
||||
;
|
||||
;extension=php_bz2.dll
|
||||
;extension=php_ctype.dll
|
||||
;extension=php_cpdf.dll
|
||||
;extension=php_crack.dll
|
||||
;extension=php_curl.dll
|
||||
;extension=php_cybercash.dll
|
||||
;extension=php_db.dll
|
||||
;extension=php_dba.dll
|
||||
;extension=php_dbase.dll
|
||||
;extension=php_dbx.dll
|
||||
;extension=php_domxml.dll
|
||||
;extension=php_dotnet.dll
|
||||
;extension=php_exif.dll
|
||||
;extension=php_fbsql.dll
|
||||
;extension=php_fdf.dll
|
||||
;extension=php_filepro.dll
|
||||
;extension=php_gd.dll
|
||||
;extension=php_gettext.dll
|
||||
;extension=php_hyperwave.dll
|
||||
;extension=php_iconv.dll
|
||||
;extension=php_ifx.dll
|
||||
;extension=php_iisfunc.dll
|
||||
;extension=php_imap.dll
|
||||
;extension=php_ingres.dll
|
||||
;extension=php_interbase.dll
|
||||
;extension=php_java.dll
|
||||
;extension=php_ldap.dll
|
||||
;extension=php_mbstring.dll
|
||||
;extension=php_mcrypt.dll
|
||||
;extension=php_mhash.dll
|
||||
;extension=php_ming.dll
|
||||
;extension=php_mssql.dll
|
||||
;extension=php_oci8.dll
|
||||
;extension=php_openssl.dll
|
||||
;extension=php_oracle.dll
|
||||
;extension=php_pdf.dll
|
||||
;extension=php_pgsql.dll
|
||||
;extension=php_printer.dll
|
||||
;extension=php_shmop.dll
|
||||
;extension=php_snmp.dll
|
||||
;extension=php_sockets.dll
|
||||
;extension=php_sybase_ct.dll
|
||||
;extension=php_tokenizer.dll
|
||||
;extension=php_w32api.dll
|
||||
;extension=php_xslt.dll
|
||||
;extension=php_yaz.dll
|
||||
;extension=php_zlib.dll
|
||||
|
||||
|
||||
;;;;;;;;;;;;;;;;;;;
|
||||
; Module Settings ;
|
||||
;;;;;;;;;;;;;;;;;;;
|
||||
|
||||
[Syslog]
|
||||
; Whether or not to define the various syslog variables (e.g. $LOG_PID,
|
||||
; $LOG_CRON, etc.). Turning it off is a good idea performance-wise. In
|
||||
; runtime, you can define these variables by calling define_syslog_variables().
|
||||
define_syslog_variables = Off
|
||||
|
||||
[mail function]
|
||||
; For Win32 only.
|
||||
SMTP = localhost
|
||||
|
||||
; For Win32 only.
|
||||
sendmail_from = me@localhost.com
|
||||
|
||||
; For Unix only. You may supply arguments as well (default: "sendmail -t -i").
|
||||
;sendmail_path =
|
||||
|
||||
[Java]
|
||||
;java.class.path = .\php_java.jar
|
||||
;java.home = c:\jdk
|
||||
;java.library = c:\jdk\jre\bin\hotspot\jvm.dll
|
||||
;java.library.path = .\
|
||||
|
||||
[SQL]
|
||||
sql.safe_mode = Off
|
||||
|
||||
[ODBC]
|
||||
;odbc.default_db = Not yet implemented
|
||||
;odbc.default_user = Not yet implemented
|
||||
;odbc.default_pw = Not yet implemented
|
||||
|
||||
; Allow or prevent persistent links.
|
||||
odbc.allow_persistent = On
|
||||
|
||||
; Check that a connection is still valid before reuse.
|
||||
odbc.check_persistent = On
|
||||
|
||||
; Maximum number of persistent links. -1 means no limit.
|
||||
odbc.max_persistent = -1
|
||||
|
||||
; Maximum number of links (persistent + non-persistent). -1 means no limit.
|
||||
odbc.max_links = -1
|
||||
|
||||
; Handling of LONG fields. Returns number of bytes to variables. 0 means
|
||||
; passthru.
|
||||
odbc.defaultlrl = 4096
|
||||
|
||||
; Handling of binary data. 0 means passthru, 1 return as is, 2 convert to char.
|
||||
; See the documentation on odbc_binmode and odbc_longreadlen for an explanation
|
||||
; of uodbc.defaultlrl and uodbc.defaultbinmode
|
||||
odbc.defaultbinmode = 1
|
||||
|
||||
[MySQL]
|
||||
; Allow or prevent persistent links.
|
||||
mysql.allow_persistent = On
|
||||
|
||||
; Maximum number of persistent links. -1 means no limit.
|
||||
mysql.max_persistent = -1
|
||||
|
||||
; Maximum number of links (persistent + non-persistent). -1 means no limit.
|
||||
mysql.max_links = -1
|
||||
|
||||
; Default port number for mysql_connect(). If unset, mysql_connect() will use
|
||||
; the $MYSQL_TCP_PORT or the mysql-tcp entry in /etc/services or the
|
||||
; compile-time value defined MYSQL_PORT (in that order). Win32 will only look
|
||||
; at MYSQL_PORT.
|
||||
mysql.default_port =
|
||||
|
||||
; Default socket name for local MySQL connects. If empty, uses the built-in
|
||||
; MySQL defaults.
|
||||
mysql.default_socket =
|
||||
|
||||
; Default host for mysql_connect() (doesn't apply in safe mode).
|
||||
mysql.default_host =
|
||||
|
||||
; Default user for mysql_connect() (doesn't apply in safe mode).
|
||||
mysql.default_user =
|
||||
|
||||
; Default password for mysql_connect() (doesn't apply in safe mode).
|
||||
; Note that this is generally a *bad* idea to store passwords in this file.
|
||||
; *Any* user with PHP access can run 'echo get_cfg_var("mysql.default_password")
|
||||
; and reveal this password! And of course, any users with read access to this
|
||||
; file will be able to reveal the password as well.
|
||||
mysql.default_password =
|
||||
|
||||
[mSQL]
|
||||
; Allow or prevent persistent links.
|
||||
msql.allow_persistent = On
|
||||
|
||||
; Maximum number of persistent links. -1 means no limit.
|
||||
msql.max_persistent = -1
|
||||
|
||||
; Maximum number of links (persistent+non persistent). -1 means no limit.
|
||||
msql.max_links = -1
|
||||
|
||||
[PostgresSQL]
|
||||
; Allow or prevent persistent links.
|
||||
pgsql.allow_persistent = On
|
||||
|
||||
; Detect broken persistent links always with pg_pconnect(). Need a little overhead.
|
||||
pgsql.auto_reset_persistent = Off
|
||||
|
||||
; Maximum number of persistent links. -1 means no limit.
|
||||
pgsql.max_persistent = -1
|
||||
|
||||
; Maximum number of links (persistent+non persistent). -1 means no limit.
|
||||
pgsql.max_links = -1
|
||||
|
||||
; Ignore PostgreSQL backends Notice message or not.
|
||||
pgsql.ignore_notice = 0
|
||||
|
||||
; Log PostgreSQL backends Noitce message or not.
|
||||
; Unless pgsql.ignore_notice=0, module cannot log notice message.
|
||||
pgsql.log_notice = 0
|
||||
|
||||
[Sybase]
|
||||
; Allow or prevent persistent links.
|
||||
sybase.allow_persistent = On
|
||||
|
||||
; Maximum number of persistent links. -1 means no limit.
|
||||
sybase.max_persistent = -1
|
||||
|
||||
; Maximum number of links (persistent + non-persistent). -1 means no limit.
|
||||
sybase.max_links = -1
|
||||
|
||||
;sybase.interface_file = "/usr/sybase/interfaces"
|
||||
|
||||
; Minimum error severity to display.
|
||||
sybase.min_error_severity = 10
|
||||
|
||||
; Minimum message severity to display.
|
||||
sybase.min_message_severity = 10
|
||||
|
||||
; Compatability mode with old versions of PHP 3.0.
|
||||
; If on, this will cause PHP to automatically assign types to results according
|
||||
; to their Sybase type, instead of treating them all as strings. This
|
||||
; compatability mode will probably not stay around forever, so try applying
|
||||
; whatever necessary changes to your code, and turn it off.
|
||||
sybase.compatability_mode = Off
|
||||
|
||||
[Sybase-CT]
|
||||
; Allow or prevent persistent links.
|
||||
sybct.allow_persistent = On
|
||||
|
||||
; Maximum number of persistent links. -1 means no limit.
|
||||
sybct.max_persistent = -1
|
||||
|
||||
; Maximum number of links (persistent + non-persistent). -1 means no limit.
|
||||
sybct.max_links = -1
|
||||
|
||||
; Minimum server message severity to display.
|
||||
sybct.min_server_severity = 10
|
||||
|
||||
; Minimum client message severity to display.
|
||||
sybct.min_client_severity = 10
|
||||
|
||||
[bcmath]
|
||||
; Number of decimal digits for all bcmath functions.
|
||||
bcmath.scale = 0
|
||||
|
||||
[browscap]
|
||||
;browscap = extra/browscap.ini
|
||||
|
||||
[Informix]
|
||||
; Default host for ifx_connect() (doesn't apply in safe mode).
|
||||
ifx.default_host =
|
||||
|
||||
; Default user for ifx_connect() (doesn't apply in safe mode).
|
||||
ifx.default_user =
|
||||
|
||||
; Default password for ifx_connect() (doesn't apply in safe mode).
|
||||
ifx.default_password =
|
||||
|
||||
; Allow or prevent persistent links.
|
||||
ifx.allow_persistent = On
|
||||
|
||||
; Maximum number of persistent links. -1 means no limit.
|
||||
ifx.max_persistent = -1
|
||||
|
||||
; Maximum number of links (persistent + non-persistent). -1 means no limit.
|
||||
ifx.max_links = -1
|
||||
|
||||
; If on, select statements return the contents of a text blob instead of its id.
|
||||
ifx.textasvarchar = 0
|
||||
|
||||
; If on, select statements return the contents of a byte blob instead of its id.
|
||||
ifx.byteasvarchar = 0
|
||||
|
||||
; Trailing blanks are stripped from fixed-length char columns. May help the
|
||||
; life of Informix SE users.
|
||||
ifx.charasvarchar = 0
|
||||
|
||||
; If on, the contents of text and byte blobs are dumped to a file instead of
|
||||
; keeping them in memory.
|
||||
ifx.blobinfile = 0
|
||||
|
||||
; NULL's are returned as empty strings, unless this is set to 1. In that case,
|
||||
; NULL's are returned as string 'NULL'.
|
||||
ifx.nullformat = 0
|
||||
|
||||
[Session]
|
||||
; Handler used to store/retrieve data.
|
||||
session.save_handler = files
|
||||
|
||||
; Argument passed to save_handler. In the case of files, this is the path
|
||||
; where data files are stored. Note: Windows users have to change this
|
||||
; variable in order to use PHP's session functions.
|
||||
session.save_path = /tmp
|
||||
|
||||
; Whether to use cookies.
|
||||
session.use_cookies = 1
|
||||
|
||||
; This option enables administrators to make their users invulnerable to
|
||||
; attacks which involve passing session ids in URLs; defaults to 0.
|
||||
; session.use_only_cookies = 1
|
||||
|
||||
; Name of the session (used as cookie name).
|
||||
session.name = PHPSESSID
|
||||
|
||||
; Initialize session on request startup.
|
||||
session.auto_start = 0
|
||||
|
||||
; Lifetime in seconds of cookie or, if 0, until browser is restarted.
|
||||
session.cookie_lifetime = 0
|
||||
|
||||
; The path for which the cookie is valid.
|
||||
session.cookie_path = /
|
||||
|
||||
; The domain for which the cookie is valid.
|
||||
session.cookie_domain =
|
||||
|
||||
; Handler used to serialize data. php is the standard serializer of PHP.
|
||||
session.serialize_handler = php
|
||||
|
||||
; Percentual probability that the 'garbage collection' process is started
|
||||
; on every session initialization.
|
||||
session.gc_probability = 1
|
||||
|
||||
; After this number of seconds, stored data will be seen as 'garbage' and
|
||||
; cleaned up by the garbage collection process.
|
||||
session.gc_maxlifetime = 1440
|
||||
|
||||
; Check HTTP Referer to invalidate externally stored URLs containing ids.
|
||||
; HTTP_REFERER has to contain this substring for the session to be
|
||||
; considered as valid.
|
||||
session.referer_check =
|
||||
|
||||
; How many bytes to read from the file.
|
||||
session.entropy_length = 0
|
||||
|
||||
; Specified here to create the session id.
|
||||
session.entropy_file =
|
||||
|
||||
;session.entropy_length = 16
|
||||
|
||||
;session.entropy_file = /dev/urandom
|
||||
|
||||
; Set to {nocache,private,public} to determine HTTP caching aspects.
|
||||
session.cache_limiter = nocache
|
||||
|
||||
; Document expires after n minutes.
|
||||
session.cache_expire = 180
|
||||
|
||||
; use transient sid support if enabled by compiling with --enable-trans-sid.
|
||||
session.use_trans_sid = 1
|
||||
|
||||
url_rewriter.tags = "a=href,area=href,frame=src,input=src,form=fakeentry"
|
||||
|
||||
[MSSQL]
|
||||
; Allow or prevent persistent links.
|
||||
mssql.allow_persistent = On
|
||||
|
||||
; Maximum number of persistent links. -1 means no limit.
|
||||
mssql.max_persistent = -1
|
||||
|
||||
; Maximum number of links (persistent+non persistent). -1 means no limit.
|
||||
mssql.max_links = -1
|
||||
|
||||
; Minimum error severity to display.
|
||||
mssql.min_error_severity = 10
|
||||
|
||||
; Minimum message severity to display.
|
||||
mssql.min_message_severity = 10
|
||||
|
||||
; Compatability mode with old versions of PHP 3.0.
|
||||
mssql.compatability_mode = Off
|
||||
|
||||
; Valid range 0 - 2147483647. Default = 4096.
|
||||
;mssql.textlimit = 4096
|
||||
|
||||
; Valid range 0 - 2147483647. Default = 4096.
|
||||
;mssql.textsize = 4096
|
||||
|
||||
; Limits the number of records in each batch. 0 = all records in one batch.
|
||||
;mssql.batchsize = 0
|
||||
|
||||
; Use NT authentication when connecting to the server
|
||||
mssql.secure_connection = Off
|
||||
|
||||
; Specify max number of processes. Default = 25
|
||||
;mssql.max_procs = 25
|
||||
|
||||
[Assertion]
|
||||
; Assert(expr); active by default.
|
||||
;assert.active = On
|
||||
|
||||
; Issue a PHP warning for each failed assertion.
|
||||
;assert.warning = On
|
||||
|
||||
; Don't bail out by default.
|
||||
;assert.bail = Off
|
||||
|
||||
; User-function to be called if an assertion fails.
|
||||
;assert.callback = 0
|
||||
|
||||
; Eval the expression with current error_reporting(). Set to true if you want
|
||||
; error_reporting(0) around the eval().
|
||||
;assert.quiet_eval = 0
|
||||
|
||||
[Ingres II]
|
||||
; Allow or prevent persistent links.
|
||||
ingres.allow_persistent = On
|
||||
|
||||
; Maximum number of persistent links. -1 means no limit.
|
||||
ingres.max_persistent = -1
|
||||
|
||||
; Maximum number of links, including persistents. -1 means no limit.
|
||||
ingres.max_links = -1
|
||||
|
||||
; Default database (format: [node_id::]dbname[/srv_class]).
|
||||
ingres.default_database =
|
||||
|
||||
; Default user.
|
||||
ingres.default_user =
|
||||
|
||||
; Default password.
|
||||
ingres.default_password =
|
||||
|
||||
[Verisign Payflow Pro]
|
||||
; Default Payflow Pro server.
|
||||
pfpro.defaulthost = "test-payflow.verisign.com"
|
||||
|
||||
; Default port to connect to.
|
||||
pfpro.defaultport = 443
|
||||
|
||||
; Default timeout in seconds.
|
||||
pfpro.defaulttimeout = 30
|
||||
|
||||
; Default proxy IP address (if required).
|
||||
;pfpro.proxyaddress =
|
||||
|
||||
; Default proxy port.
|
||||
;pfpro.proxyport =
|
||||
|
||||
; Default proxy logon.
|
||||
;pfpro.proxylogon =
|
||||
|
||||
; Default proxy password.
|
||||
;pfpro.proxypassword =
|
||||
|
||||
[Sockets]
|
||||
; Use the system read() function instead of the php_read() wrapper.
|
||||
sockets.use_system_read = On
|
||||
|
||||
[com]
|
||||
; path to a file containing GUIDs, IIDs or filenames of files with TypeLibs
|
||||
;com.typelib_file =
|
||||
; allow Distributed-COM calls
|
||||
;com.allow_dcom = true
|
||||
; autoregister constants of a components typlib on com_load()
|
||||
;com.autoregister_typelib = true
|
||||
; register constants casesensitive
|
||||
;com.autoregister_casesensitive = false
|
||||
; show warnings on duplicate constat registrations
|
||||
;com.autoregister_verbose = true
|
||||
|
||||
[Printer]
|
||||
;printer.default_printer = ""
|
||||
|
||||
[mbstring]
|
||||
; internal/script encoding.
|
||||
; Some encoding cannot work as internal encoding.
|
||||
; (e.g. SJIS, BIG5, ISO-2022-*)
|
||||
;mbstring.internal_encoding = EUC-JP
|
||||
|
||||
; http input encoding.
|
||||
;mbstring.http_input = auto
|
||||
|
||||
; http output encoding. mb_output_handler must be
|
||||
; registered as output buffer to function
|
||||
;mbstring.http_output = SJIS
|
||||
|
||||
; automatic encoding detection order.
|
||||
; auto means
|
||||
;mbstring.detect_order = auto
|
||||
|
||||
; substitute_character used when character cannot be converted
|
||||
; one from another
|
||||
;mbstring.substitute_character = none;
|
||||
|
||||
; overload(replace) single byte functions by mbstring functions.
|
||||
; mail(), ereg(), etc are overloaded by mb_send_mail(), mb_ereg(),
|
||||
; etc.
|
||||
;mbstring.func_overload = No
|
||||
|
||||
[FrontBase]
|
||||
;fbsql.allow_persistent = On
|
||||
;fbsql.autocommit = On
|
||||
;fbsql.default_database =
|
||||
;fbsql.default_database_password =
|
||||
;fbsql.default_host =
|
||||
;fbsql.default_password =
|
||||
;fbsql.default_user = "_SYSTEM"
|
||||
;fbsql.generate_warnings = Off
|
||||
;fbsql.max_connections = 128
|
||||
;fbsql.max_links = 128
|
||||
;fbsql.max_persistent = -1
|
||||
;fbsql.max_results = 128
|
||||
;fbsql.batchSize = 1000
|
||||
|
||||
[Crack]
|
||||
; Modify the setting below to match the directory location of the cracklib
|
||||
; dictionary files. Include the base filename, but not the file extension.
|
||||
; crack.default_dictionary = "c:\php\lib\cracklib_dict"
|
||||
|
||||
; Local Variables:
|
||||
; tab-width: 4
|
||||
; End:
|
||||
@@ -1,955 +0,0 @@
|
||||
[PHP]
|
||||
|
||||
;;;;;;;;;;;;;;;;;;;
|
||||
; About this file ;
|
||||
;;;;;;;;;;;;;;;;;;;
|
||||
;
|
||||
; This is the recommended, PHP 4-style version of the php.ini-dist file. It
|
||||
; sets some non standard settings, that make PHP more efficient, more secure,
|
||||
; and encourage cleaner coding.
|
||||
; The price is that with these settings, PHP may be incompatible with some
|
||||
; applications, and sometimes, more difficult to develop with. Using this
|
||||
; file is warmly recommended for production sites. As all of the changes from
|
||||
; the standard settings are thoroughly documented, you can go over each one,
|
||||
; and decide whether you want to use it or not.
|
||||
;
|
||||
; For general information about the php.ini file, please consult the php.ini-dist
|
||||
; file, included in your PHP distribution.
|
||||
;
|
||||
; This file is different from the php.ini-dist file in the fact that it features
|
||||
; different values for several directives, in order to improve performance, while
|
||||
; possibly breaking compatibility with the standard out-of-the-box behavior of
|
||||
; PHP 3. Please make sure you read what's different, and modify your scripts
|
||||
; accordingly, if you decide to use this file instead.
|
||||
;
|
||||
; - register_globals = Off [Security, Performance]
|
||||
; Global variables are no longer registered for input data (POST, GET, cookies,
|
||||
; environment and other server variables). Instead of using $foo, you must use
|
||||
; you can use $_REQUEST["foo"] (includes any variable that arrives through the
|
||||
; request, namely, POST, GET and cookie variables), or use one of the specific
|
||||
; $_GET["foo"], $_POST["foo"], $_COOKIE["foo"] or $_FILES["foo"], depending
|
||||
; on where the input originates. Also, you can look at the
|
||||
; import_request_variables() function.
|
||||
; Note that register_globals is going to be depracated (i.e., turned off by
|
||||
; default) in the next version of PHP, because it often leads to security bugs.
|
||||
; Read http://php.net/manual/en/security.registerglobals.php for further
|
||||
; information.
|
||||
; - display_errors = Off [Security]
|
||||
; With this directive set to off, errors that occur during the execution of
|
||||
; scripts will no longer be displayed as a part of the script output, and thus,
|
||||
; will no longer be exposed to remote users. With some errors, the error message
|
||||
; content may expose information about your script, web server, or database
|
||||
; server that may be exploitable for hacking. Production sites should have this
|
||||
; directive set to off.
|
||||
; - log_errors = On [Security]
|
||||
; This directive complements the above one. Any errors that occur during the
|
||||
; execution of your script will be logged (typically, to your server's error log,
|
||||
; but can be configured in several ways). Along with setting display_errors to off,
|
||||
; this setup gives you the ability to fully understand what may have gone wrong,
|
||||
; without exposing any sensitive information to remote users.
|
||||
; - output_buffering = 4096 [Performance]
|
||||
; Set a 4KB output buffer. Enabling output buffering typically results in less
|
||||
; writes, and sometimes less packets sent on the wire, which can often lead to
|
||||
; better performance. The gain this directive actually yields greatly depends
|
||||
; on which Web server you're working with, and what kind of scripts you're using.
|
||||
; - register_argc_argv = Off [Performance]
|
||||
; Disables registration of the somewhat redundant $argv and $argc global
|
||||
; variables.
|
||||
; - magic_quotes_gpc = Off [Performance]
|
||||
; Input data is no longer escaped with slashes so that it can be sent into
|
||||
; SQL databases without further manipulation. Instead, you should use the
|
||||
; function addslashes() on each input element you wish to send to a database.
|
||||
; - variables_order = "GPCS" [Performance]
|
||||
; The environment variables are not hashed into the $HTTP_ENV_VARS[]. To access
|
||||
; environment variables, you can use getenv() instead.
|
||||
; - error_reporting = E_ALL [Code Cleanliness, Security(?)]
|
||||
; By default, PHP surpresses errors of type E_NOTICE. These error messages
|
||||
; are emitted for non-critical errors, but that could be a symptom of a bigger
|
||||
; problem. Most notably, this will cause error messages about the use
|
||||
; of uninitialized variables to be displayed.
|
||||
; - allow_call_time_pass_reference = Off [Code cleanliness]
|
||||
; It's not possible to decide to force a variable to be passed by reference
|
||||
; when calling a function. The PHP 4 style to do this is by making the
|
||||
; function require the relevant argument by reference.
|
||||
|
||||
|
||||
;;;;;;;;;;;;;;;;;;;;
|
||||
; Language Options ;
|
||||
;;;;;;;;;;;;;;;;;;;;
|
||||
|
||||
; Enable the PHP scripting language engine under Apache.
|
||||
engine = On
|
||||
|
||||
; Allow the <? tag. Otherwise, only <?php and <script> tags are recognized.
|
||||
short_open_tag = On
|
||||
|
||||
; Allow ASP-style <% %> tags.
|
||||
asp_tags = Off
|
||||
|
||||
; The number of significant digits displayed in floating point numbers.
|
||||
precision = 14
|
||||
|
||||
; Enforce year 2000 compliance (will cause problems with non-compliant browsers)
|
||||
y2k_compliance = Off
|
||||
|
||||
; Output buffering allows you to send header lines (including cookies) even
|
||||
; after you send body content, at the price of slowing PHP's output layer a
|
||||
; bit. You can enable output buffering during runtime by calling the output
|
||||
; buffering functions. You can also enable output buffering for all files by
|
||||
; setting this directive to On. If you wish to limit the size of the buffer
|
||||
; to a certain size - you can use a maximum number of bytes instead of 'On', as
|
||||
; a value for this directive (e.g., output_buffering=4096).
|
||||
output_buffering = 4096
|
||||
|
||||
; You can redirect all of the output of your scripts to a function. For
|
||||
; example, if you set output_handler to "ob_gzhandler", output will be
|
||||
; transparently compressed for browsers that support gzip or deflate encoding.
|
||||
; Setting an output handler automatically turns on output buffering.
|
||||
output_handler =
|
||||
|
||||
; Transparent output compression using the zlib library
|
||||
; Valid values for this option are 'off', 'on', or a specific buffer size
|
||||
; to be used for compression (default is 4KB)
|
||||
;
|
||||
; Note: output_handler must be empty if this is set 'On' !!!!
|
||||
;
|
||||
zlib.output_compression = Off
|
||||
|
||||
; Implicit flush tells PHP to tell the output layer to flush itself
|
||||
; automatically after every output block. This is equivalent to calling the
|
||||
; PHP function flush() after each and every call to print() or echo() and each
|
||||
; and every HTML block. Turning this option on has serious performance
|
||||
; implications and is generally recommended for debugging purposes only.
|
||||
implicit_flush = Off
|
||||
|
||||
; Whether to enable the ability to force arguments to be passed by reference
|
||||
; at function call time. This method is deprecated and is likely to be
|
||||
; unsupported in future versions of PHP/Zend. The encouraged method of
|
||||
; specifying which arguments should be passed by reference is in the function
|
||||
; declaration. You're encouraged to try and turn this option Off and make
|
||||
; sure your scripts work properly with it in order to ensure they will work
|
||||
; with future versions of the language (you will receive a warning each time
|
||||
; you use this feature, and the argument will be passed by value instead of by
|
||||
; reference).
|
||||
allow_call_time_pass_reference = Off
|
||||
|
||||
;
|
||||
; Safe Mode
|
||||
;
|
||||
safe_mode = Off
|
||||
|
||||
; By default, Safe Mode does a UID compare check when
|
||||
; opening files. If you want to relax this to a GID compare,
|
||||
; then turn on safe_mode_gid.
|
||||
safe_mode_gid = Off
|
||||
|
||||
; When safe_mode is on, UID/GID checks are bypassed when
|
||||
; including files from this directory and its subdirectories.
|
||||
; (directory must also be in include_path or full path must
|
||||
; be used when including)
|
||||
safe_mode_include_dir =
|
||||
|
||||
; When safe_mode is on, only executables located in the safe_mode_exec_dir
|
||||
; will be allowed to be executed via the exec family of functions.
|
||||
safe_mode_exec_dir =
|
||||
|
||||
; open_basedir, if set, limits all file operations to the defined directory
|
||||
; and below. This directive makes most sense if used in a per-directory
|
||||
; or per-virtualhost web server configuration file.
|
||||
;
|
||||
;open_basedir =
|
||||
|
||||
; Setting certain environment variables may be a potential security breach.
|
||||
; This directive contains a comma-delimited list of prefixes. In Safe Mode,
|
||||
; the user may only alter environment variables whose names begin with the
|
||||
; prefixes supplied here. By default, users will only be able to set
|
||||
; environment variables that begin with PHP_ (e.g. PHP_FOO=BAR).
|
||||
;
|
||||
; Note: If this directive is empty, PHP will let the user modify ANY
|
||||
; environment variable!
|
||||
safe_mode_allowed_env_vars = PHP_
|
||||
|
||||
; This directive contains a comma-delimited list of environment variables that
|
||||
; the end user won't be able to change using putenv(). These variables will be
|
||||
; protected even if safe_mode_allowed_env_vars is set to allow to change them.
|
||||
safe_mode_protected_env_vars = LD_LIBRARY_PATH
|
||||
|
||||
; This directive allows you to disable certain functions for security reasons.
|
||||
; It receives a comma-delimited list of function names. This directive is
|
||||
; *NOT* affected by whether Safe Mode is turned On or Off.
|
||||
disable_functions =
|
||||
|
||||
; Colors for Syntax Highlighting mode. Anything that's acceptable in
|
||||
; <font color="??????"> would work.
|
||||
highlight.string = #CC0000
|
||||
highlight.comment = #FF9900
|
||||
highlight.keyword = #006600
|
||||
highlight.bg = #FFFFFF
|
||||
highlight.default = #0000CC
|
||||
highlight.html = #000000
|
||||
|
||||
|
||||
;
|
||||
; Misc
|
||||
;
|
||||
; Decides whether PHP may expose the fact that it is installed on the server
|
||||
; (e.g. by adding its signature to the Web server header). It is no security
|
||||
; threat in any way, but it makes it possible to determine whether you use PHP
|
||||
; on your server or not.
|
||||
expose_php = On
|
||||
|
||||
|
||||
;;;;;;;;;;;;;;;;;;;
|
||||
; Resource Limits ;
|
||||
;;;;;;;;;;;;;;;;;;;
|
||||
|
||||
max_execution_time = 30 ; Maximum execution time of each script, in seconds
|
||||
memory_limit = 8M ; Maximum amount of memory a script may consume (8MB)
|
||||
|
||||
|
||||
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
||||
; Error handling and logging ;
|
||||
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
||||
|
||||
; error_reporting is a bit-field. Or each number up to get desired error
|
||||
; reporting level
|
||||
; E_ALL - All errors and warnings
|
||||
; E_ERROR - fatal run-time errors
|
||||
; E_WARNING - run-time warnings (non-fatal errors)
|
||||
; E_PARSE - compile-time parse errors
|
||||
; E_NOTICE - run-time notices (these are warnings which often result
|
||||
; from a bug in your code, but it's possible that it was
|
||||
; intentional (e.g., using an uninitialized variable and
|
||||
; relying on the fact it's automatically initialized to an
|
||||
; empty string)
|
||||
; E_CORE_ERROR - fatal errors that occur during PHP's initial startup
|
||||
; E_CORE_WARNING - warnings (non-fatal errors) that occur during PHP's
|
||||
; initial startup
|
||||
; E_COMPILE_ERROR - fatal compile-time errors
|
||||
; E_COMPILE_WARNING - compile-time warnings (non-fatal errors)
|
||||
; E_USER_ERROR - user-generated error message
|
||||
; E_USER_WARNING - user-generated warning message
|
||||
; E_USER_NOTICE - user-generated notice message
|
||||
;
|
||||
; Examples:
|
||||
;
|
||||
; - Show all errors, except for notices
|
||||
;
|
||||
;error_reporting = E_ALL & ~E_NOTICE
|
||||
;
|
||||
; - Show only errors
|
||||
;
|
||||
;error_reporting = E_COMPILE_ERROR|E_ERROR|E_CORE_ERROR
|
||||
;
|
||||
; - Show all errors
|
||||
;
|
||||
error_reporting = E_ALL
|
||||
|
||||
; Print out errors (as a part of the output). For production web sites,
|
||||
; you're strongly encouraged to turn this feature off, and use error logging
|
||||
; instead (see below). Keeping display_errors enabled on a production web site
|
||||
; may reveal security information to end users, such as file paths on your Web
|
||||
; server, your database schema or other information.
|
||||
display_errors = Off
|
||||
|
||||
; Even when display_errors is on, errors that occur during PHP's startup
|
||||
; sequence are not displayed. It's strongly recommended to keep
|
||||
; display_startup_errors off, except for when debugging.
|
||||
display_startup_errors = Off
|
||||
|
||||
; Log errors into a log file (server-specific log, stderr, or error_log (below))
|
||||
; As stated above, you're strongly advised to use error logging in place of
|
||||
; error displaying on production web sites.
|
||||
log_errors = On
|
||||
|
||||
; Set maximum length of log_errors. In error_log information about the source is
|
||||
; added. The default is 1024 and 0 allows to not apply any maximum length at all.
|
||||
log_errors_max_len = 1024
|
||||
|
||||
; Do not log repeated messages. Repeated errors must occur in same file on same
|
||||
; line until ignore_repeated_source is set true.
|
||||
ignore_repeated_errors = Off
|
||||
|
||||
; Ignore source of message when ignoring repeated messages. When this setting
|
||||
; is On you will not log errors with repeated messages from different files or
|
||||
; sourcelines.
|
||||
ignore_repeated_source = Off
|
||||
|
||||
; If this parameter is set to Off, then memory leaks will not be shown (on
|
||||
; stdout or in the log). This has only effect in a debug compile, and if
|
||||
; error reporting includes E_WARNING in the allowed list
|
||||
report_memleaks = On
|
||||
|
||||
; Store the last error/warning message in $php_errormsg (boolean).
|
||||
track_errors = Off
|
||||
|
||||
; Disable the inclusion of HTML tags in error messages.
|
||||
;html_errors = Off
|
||||
|
||||
; String to output before an error message.
|
||||
;error_prepend_string = "<font color=ff0000>"
|
||||
|
||||
; String to output after an error message.
|
||||
;error_append_string = "</font>"
|
||||
|
||||
; Log errors to specified file.
|
||||
;error_log = filename
|
||||
|
||||
; Log errors to syslog (Event Log on NT, not valid in Windows 95).
|
||||
;error_log = syslog
|
||||
|
||||
; Warn if the + operator is used with strings.
|
||||
warn_plus_overloading = Off
|
||||
|
||||
|
||||
;;;;;;;;;;;;;;;;;
|
||||
; Data Handling ;
|
||||
;;;;;;;;;;;;;;;;;
|
||||
;
|
||||
; Note - track_vars is ALWAYS enabled as of PHP 4.0.3
|
||||
|
||||
; The separator used in PHP generated URLs to separate arguments.
|
||||
; Default is "&".
|
||||
;arg_separator.output = "&"
|
||||
|
||||
; List of separator(s) used by PHP to parse input URLs into variables.
|
||||
; Default is "&".
|
||||
; NOTE: Every character in this directive is considered as separator!
|
||||
;arg_separator.input = ";&"
|
||||
|
||||
; This directive describes the order in which PHP registers GET, POST, Cookie,
|
||||
; Environment and Built-in variables (G, P, C, E & S respectively, often
|
||||
; referred to as EGPCS or GPC). Registration is done from left to right, newer
|
||||
; values override older values.
|
||||
variables_order = "GPCS"
|
||||
|
||||
; Whether or not to register the EGPCS variables as global variables. You may
|
||||
; want to turn this off if you don't want to clutter your scripts' global scope
|
||||
; with user data. This makes most sense when coupled with track_vars - in which
|
||||
; case you can access all of the GPC variables through the $HTTP_*_VARS[],
|
||||
; variables.
|
||||
;
|
||||
; You should do your best to write your scripts so that they do not require
|
||||
; register_globals to be on; Using form variables as globals can easily lead
|
||||
; to possible security problems, if the code is not very well thought of.
|
||||
register_globals = Off
|
||||
|
||||
; This directive tells PHP whether to declare the argv&argc variables (that
|
||||
; would contain the GET information). If you don't use these variables, you
|
||||
; should turn it off for increased performance.
|
||||
register_argc_argv = Off
|
||||
|
||||
; Maximum size of POST data that PHP will accept.
|
||||
post_max_size = 8M
|
||||
|
||||
; This directive is deprecated. Use variables_order instead.
|
||||
gpc_order = "GPC"
|
||||
|
||||
; Magic quotes
|
||||
;
|
||||
|
||||
; Magic quotes for incoming GET/POST/Cookie data.
|
||||
magic_quotes_gpc = Off
|
||||
|
||||
; Magic quotes for runtime-generated data, e.g. data from SQL, from exec(), etc.
|
||||
magic_quotes_runtime = Off
|
||||
|
||||
; Use Sybase-style magic quotes (escape ' with '' instead of \').
|
||||
magic_quotes_sybase = Off
|
||||
|
||||
; Automatically add files before or after any PHP document.
|
||||
auto_prepend_file =
|
||||
auto_append_file =
|
||||
|
||||
; As of 4.0b4, PHP always outputs a character encoding by default in
|
||||
; the Content-type: header. To disable sending of the charset, simply
|
||||
; set it to be empty.
|
||||
;
|
||||
; PHP's built-in default is text/html
|
||||
default_mimetype = "text/html"
|
||||
;default_charset = "iso-8859-1"
|
||||
|
||||
; Always populate the $HTTP_RAW_POST_DATA variable.
|
||||
;always_populate_raw_post_data = On
|
||||
|
||||
;;;;;;;;;;;;;;;;;;;;;;;;;
|
||||
; Paths and Directories ;
|
||||
;;;;;;;;;;;;;;;;;;;;;;;;;
|
||||
|
||||
; UNIX: "/path1:/path2"
|
||||
;include_path = ".:/php/includes"
|
||||
;
|
||||
; Windows: "\path1;\path2"
|
||||
;include_path = ".;c:\php\includes"
|
||||
|
||||
; The root of the PHP pages, used only if nonempty.
|
||||
; if PHP was not compiled with FORCE_REDIRECT, you SHOULD set doc_root
|
||||
; if you are running php as a CGI under any web server (other than IIS)
|
||||
; see documentation for security issues. The alternate is to use the
|
||||
; cgi.force_redirect configuration below
|
||||
doc_root =
|
||||
|
||||
; The directory under which PHP opens the script using /~usernamem used only
|
||||
; if nonempty.
|
||||
user_dir =
|
||||
|
||||
; Directory in which the loadable extensions (modules) reside.
|
||||
extension_dir = ./
|
||||
|
||||
; Whether or not to enable the dl() function. The dl() function does NOT work
|
||||
; properly in multithreaded servers, such as IIS or Zeus, and is automatically
|
||||
; disabled on them.
|
||||
enable_dl = On
|
||||
|
||||
; cgi.force_redirect is necessary to provide security running PHP as a CGI under
|
||||
; most web servers. Left undefined, PHP turns this on by default. You can
|
||||
; turn it off here AT YOUR OWN RISK
|
||||
; **You CAN safely turn this off for IIS, in fact, you MUST.**
|
||||
; cgi.force_redirect = 1
|
||||
|
||||
; if cgi.force_redirect is turned on, and you are not running under Apache or Netscape
|
||||
; (iPlanet) web servers, you MAY need to set an environment variable name that PHP
|
||||
; will look for to know it is OK to continue execution. Setting this variable MAY
|
||||
; cause security issues, KNOW WHAT YOU ARE DOING FIRST.
|
||||
; cgi.redirect_status_env = ;
|
||||
|
||||
; FastCGI under IIS (on WINNT based OS) supports the ability to impersonate
|
||||
; security tokens of the calling client. This allows IIS to define the
|
||||
; security context that the request runs under. mod_fastcgi under Apache
|
||||
; does not currently support this feature (03/17/2002)
|
||||
; Set to 1 if running under IIS. Default is zero.
|
||||
; fastcgi.impersonate = 1;
|
||||
|
||||
;;;;;;;;;;;;;;;;
|
||||
; File Uploads ;
|
||||
;;;;;;;;;;;;;;;;
|
||||
|
||||
; Whether to allow HTTP file uploads.
|
||||
file_uploads = On
|
||||
|
||||
; Temporary directory for HTTP uploaded files (will use system default if not
|
||||
; specified).
|
||||
;upload_tmp_dir =
|
||||
|
||||
; Maximum allowed size for uploaded files.
|
||||
upload_max_filesize = 2M
|
||||
|
||||
|
||||
;;;;;;;;;;;;;;;;;;
|
||||
; Fopen wrappers ;
|
||||
;;;;;;;;;;;;;;;;;;
|
||||
|
||||
; Whether to allow the treatment of URLs (like http:// or ftp://) as files.
|
||||
allow_url_fopen = On
|
||||
|
||||
; Define the anonymous ftp password (your email address)
|
||||
;from="john@doe.com"
|
||||
|
||||
|
||||
;;;;;;;;;;;;;;;;;;;;;;
|
||||
; Dynamic Extensions ;
|
||||
;;;;;;;;;;;;;;;;;;;;;;
|
||||
;
|
||||
; If you wish to have an extension loaded automatically, use the following
|
||||
; syntax:
|
||||
;
|
||||
; extension=modulename.extension
|
||||
;
|
||||
; For example, on Windows:
|
||||
;
|
||||
; extension=msql.dll
|
||||
;
|
||||
; ... or under UNIX:
|
||||
;
|
||||
; extension=msql.so
|
||||
;
|
||||
; Note that it should be the name of the module only; no directory information
|
||||
; needs to go here. Specify the location of the extension with the
|
||||
; extension_dir directive above.
|
||||
|
||||
|
||||
;Windows Extensions
|
||||
;Note that MySQL and ODBC support is now built in, so no dll is needed for it.
|
||||
;
|
||||
;extension=php_bz2.dll
|
||||
;extension=php_ctype.dll
|
||||
;extension=php_cpdf.dll
|
||||
;extension=php_crack.dll
|
||||
;extension=php_curl.dll
|
||||
;extension=php_cybercash.dll
|
||||
;extension=php_db.dll
|
||||
;extension=php_dba.dll
|
||||
;extension=php_dbase.dll
|
||||
;extension=php_dbx.dll
|
||||
;extension=php_domxml.dll
|
||||
;extension=php_dotnet.dll
|
||||
;extension=php_exif.dll
|
||||
;extension=php_fbsql.dll
|
||||
;extension=php_fdf.dll
|
||||
;extension=php_filepro.dll
|
||||
;extension=php_gd.dll
|
||||
;extension=php_gettext.dll
|
||||
;extension=php_hyperwave.dll
|
||||
;extension=php_iconv.dll
|
||||
;extension=php_ifx.dll
|
||||
;extension=php_iisfunc.dll
|
||||
;extension=php_imap.dll
|
||||
;extension=php_ingres.dll
|
||||
;extension=php_interbase.dll
|
||||
;extension=php_java.dll
|
||||
;extension=php_ldap.dll
|
||||
;extension=php_mbstring.dll
|
||||
;extension=php_mcrypt.dll
|
||||
;extension=php_mhash.dll
|
||||
;extension=php_ming.dll
|
||||
;extension=php_mssql.dll
|
||||
;extension=php_oci8.dll
|
||||
;extension=php_openssl.dll
|
||||
;extension=php_oracle.dll
|
||||
;extension=php_pdf.dll
|
||||
;extension=php_pgsql.dll
|
||||
;extension=php_printer.dll
|
||||
;extension=php_shmop.dll
|
||||
;extension=php_snmp.dll
|
||||
;extension=php_sockets.dll
|
||||
;extension=php_sybase_ct.dll
|
||||
;extension=php_tokenizer.dll
|
||||
;extension=php_w32api.dll
|
||||
;extension=php_xslt.dll
|
||||
;extension=php_yaz.dll
|
||||
;extension=php_zlib.dll
|
||||
|
||||
|
||||
;;;;;;;;;;;;;;;;;;;
|
||||
; Module Settings ;
|
||||
;;;;;;;;;;;;;;;;;;;
|
||||
|
||||
[Syslog]
|
||||
; Whether or not to define the various syslog variables (e.g. $LOG_PID,
|
||||
; $LOG_CRON, etc.). Turning it off is a good idea performance-wise. In
|
||||
; runtime, you can define these variables by calling define_syslog_variables().
|
||||
define_syslog_variables = Off
|
||||
|
||||
[mail function]
|
||||
; For Win32 only.
|
||||
SMTP = localhost
|
||||
|
||||
; For Win32 only.
|
||||
sendmail_from = me@localhost.com
|
||||
|
||||
; For Unix only. You may supply arguments as well (default: "sendmail -t -i").
|
||||
;sendmail_path =
|
||||
|
||||
[Java]
|
||||
;java.class.path = .\php_java.jar
|
||||
;java.home = c:\jdk
|
||||
;java.library = c:\jdk\jre\bin\hotspot\jvm.dll
|
||||
;java.library.path = .\
|
||||
|
||||
[SQL]
|
||||
sql.safe_mode = Off
|
||||
|
||||
[ODBC]
|
||||
;odbc.default_db = Not yet implemented
|
||||
;odbc.default_user = Not yet implemented
|
||||
;odbc.default_pw = Not yet implemented
|
||||
|
||||
; Allow or prevent persistent links.
|
||||
odbc.allow_persistent = On
|
||||
|
||||
; Check that a connection is still valid before reuse.
|
||||
odbc.check_persistent = On
|
||||
|
||||
; Maximum number of persistent links. -1 means no limit.
|
||||
odbc.max_persistent = -1
|
||||
|
||||
; Maximum number of links (persistent + non-persistent). -1 means no limit.
|
||||
odbc.max_links = -1
|
||||
|
||||
; Handling of LONG fields. Returns number of bytes to variables. 0 means
|
||||
; passthru.
|
||||
odbc.defaultlrl = 4096
|
||||
|
||||
; Handling of binary data. 0 means passthru, 1 return as is, 2 convert to char.
|
||||
; See the documentation on odbc_binmode and odbc_longreadlen for an explanation
|
||||
; of uodbc.defaultlrl and uodbc.defaultbinmode
|
||||
odbc.defaultbinmode = 1
|
||||
|
||||
[MySQL]
|
||||
; Allow or prevent persistent links.
|
||||
mysql.allow_persistent = On
|
||||
|
||||
; Maximum number of persistent links. -1 means no limit.
|
||||
mysql.max_persistent = -1
|
||||
|
||||
; Maximum number of links (persistent + non-persistent). -1 means no limit.
|
||||
mysql.max_links = -1
|
||||
|
||||
; Default port number for mysql_connect(). If unset, mysql_connect() will use
|
||||
; the $MYSQL_TCP_PORT or the mysql-tcp entry in /etc/services or the
|
||||
; compile-time value defined MYSQL_PORT (in that order). Win32 will only look
|
||||
; at MYSQL_PORT.
|
||||
mysql.default_port =
|
||||
|
||||
; Default socket name for local MySQL connects. If empty, uses the built-in
|
||||
; MySQL defaults.
|
||||
mysql.default_socket =
|
||||
|
||||
; Default host for mysql_connect() (doesn't apply in safe mode).
|
||||
mysql.default_host =
|
||||
|
||||
; Default user for mysql_connect() (doesn't apply in safe mode).
|
||||
mysql.default_user =
|
||||
|
||||
; Default password for mysql_connect() (doesn't apply in safe mode).
|
||||
; Note that this is generally a *bad* idea to store passwords in this file.
|
||||
; *Any* user with PHP access can run 'echo get_cfg_var("mysql.default_password")
|
||||
; and reveal this password! And of course, any users with read access to this
|
||||
; file will be able to reveal the password as well.
|
||||
mysql.default_password =
|
||||
|
||||
[mSQL]
|
||||
; Allow or prevent persistent links.
|
||||
msql.allow_persistent = On
|
||||
|
||||
; Maximum number of persistent links. -1 means no limit.
|
||||
msql.max_persistent = -1
|
||||
|
||||
; Maximum number of links (persistent+non persistent). -1 means no limit.
|
||||
msql.max_links = -1
|
||||
|
||||
[PostgresSQL]
|
||||
; Allow or prevent persistent links.
|
||||
pgsql.allow_persistent = On
|
||||
|
||||
; Detect broken persistent links always with pg_pconnect().
|
||||
; Auto reset feature requires a little overheads.
|
||||
pgsql.auto_reset_persistent = Off
|
||||
|
||||
; Maximum number of persistent links. -1 means no limit.
|
||||
pgsql.max_persistent = -1
|
||||
|
||||
; Maximum number of links (persistent+non persistent). -1 means no limit.
|
||||
pgsql.max_links = -1
|
||||
|
||||
; Ignore PostgreSQL backends Notice message or not.
|
||||
; Notice message logging require a little overheads.
|
||||
pgsql.ignore_notice = 0
|
||||
|
||||
; Log PostgreSQL backends Noitce message or not.
|
||||
; Unless pgsql.ignore_notice=0, module cannot log notice message.
|
||||
pgsql.log_notice = 0
|
||||
|
||||
[Sybase]
|
||||
; Allow or prevent persistent links.
|
||||
sybase.allow_persistent = On
|
||||
|
||||
; Maximum number of persistent links. -1 means no limit.
|
||||
sybase.max_persistent = -1
|
||||
|
||||
; Maximum number of links (persistent + non-persistent). -1 means no limit.
|
||||
sybase.max_links = -1
|
||||
|
||||
;sybase.interface_file = "/usr/sybase/interfaces"
|
||||
|
||||
; Minimum error severity to display.
|
||||
sybase.min_error_severity = 10
|
||||
|
||||
; Minimum message severity to display.
|
||||
sybase.min_message_severity = 10
|
||||
|
||||
; Compatability mode with old versions of PHP 3.0.
|
||||
; If on, this will cause PHP to automatically assign types to results according
|
||||
; to their Sybase type, instead of treating them all as strings. This
|
||||
; compatability mode will probably not stay around forever, so try applying
|
||||
; whatever necessary changes to your code, and turn it off.
|
||||
sybase.compatability_mode = Off
|
||||
|
||||
[Sybase-CT]
|
||||
; Allow or prevent persistent links.
|
||||
sybct.allow_persistent = On
|
||||
|
||||
; Maximum number of persistent links. -1 means no limit.
|
||||
sybct.max_persistent = -1
|
||||
|
||||
; Maximum number of links (persistent + non-persistent). -1 means no limit.
|
||||
sybct.max_links = -1
|
||||
|
||||
; Minimum server message severity to display.
|
||||
sybct.min_server_severity = 10
|
||||
|
||||
; Minimum client message severity to display.
|
||||
sybct.min_client_severity = 10
|
||||
|
||||
[bcmath]
|
||||
; Number of decimal digits for all bcmath functions.
|
||||
bcmath.scale = 0
|
||||
|
||||
[browscap]
|
||||
;browscap = extra/browscap.ini
|
||||
|
||||
[Informix]
|
||||
; Default host for ifx_connect() (doesn't apply in safe mode).
|
||||
ifx.default_host =
|
||||
|
||||
; Default user for ifx_connect() (doesn't apply in safe mode).
|
||||
ifx.default_user =
|
||||
|
||||
; Default password for ifx_connect() (doesn't apply in safe mode).
|
||||
ifx.default_password =
|
||||
|
||||
; Allow or prevent persistent links.
|
||||
ifx.allow_persistent = On
|
||||
|
||||
; Maximum number of persistent links. -1 means no limit.
|
||||
ifx.max_persistent = -1
|
||||
|
||||
; Maximum number of links (persistent + non-persistent). -1 means no limit.
|
||||
ifx.max_links = -1
|
||||
|
||||
; If on, select statements return the contents of a text blob instead of its id.
|
||||
ifx.textasvarchar = 0
|
||||
|
||||
; If on, select statements return the contents of a byte blob instead of its id.
|
||||
ifx.byteasvarchar = 0
|
||||
|
||||
; Trailing blanks are stripped from fixed-length char columns. May help the
|
||||
; life of Informix SE users.
|
||||
ifx.charasvarchar = 0
|
||||
|
||||
; If on, the contents of text and byte blobs are dumped to a file instead of
|
||||
; keeping them in memory.
|
||||
ifx.blobinfile = 0
|
||||
|
||||
; NULL's are returned as empty strings, unless this is set to 1. In that case,
|
||||
; NULL's are returned as string 'NULL'.
|
||||
ifx.nullformat = 0
|
||||
|
||||
[Session]
|
||||
; Handler used to store/retrieve data.
|
||||
session.save_handler = files
|
||||
|
||||
; Argument passed to save_handler. In the case of files, this is the path
|
||||
; where data files are stored. Note: Windows users have to change this
|
||||
; variable in order to use PHP's session functions.
|
||||
session.save_path = /tmp
|
||||
|
||||
; Whether to use cookies.
|
||||
session.use_cookies = 1
|
||||
|
||||
; This option enables administrators to make their users invulnerable to
|
||||
; attacks which involve passing session ids in URLs; defaults to 0.
|
||||
; session.use_only_cookies = 1
|
||||
|
||||
; Name of the session (used as cookie name).
|
||||
session.name = PHPSESSID
|
||||
|
||||
; Initialize session on request startup.
|
||||
session.auto_start = 0
|
||||
|
||||
; Lifetime in seconds of cookie or, if 0, until browser is restarted.
|
||||
session.cookie_lifetime = 0
|
||||
|
||||
; The path for which the cookie is valid.
|
||||
session.cookie_path = /
|
||||
|
||||
; The domain for which the cookie is valid.
|
||||
session.cookie_domain =
|
||||
|
||||
; Handler used to serialize data. php is the standard serializer of PHP.
|
||||
session.serialize_handler = php
|
||||
|
||||
; Percentual probability that the 'garbage collection' process is started
|
||||
; on every session initialization.
|
||||
session.gc_probability = 1
|
||||
|
||||
; After this number of seconds, stored data will be seen as 'garbage' and
|
||||
; cleaned up by the garbage collection process.
|
||||
session.gc_maxlifetime = 1440
|
||||
|
||||
; Check HTTP Referer to invalidate externally stored URLs containing ids.
|
||||
; HTTP_REFERER has to contain this substring for the session to be
|
||||
; considered as valid.
|
||||
session.referer_check =
|
||||
|
||||
; How many bytes to read from the file.
|
||||
session.entropy_length = 0
|
||||
|
||||
; Specified here to create the session id.
|
||||
session.entropy_file =
|
||||
|
||||
;session.entropy_length = 16
|
||||
|
||||
;session.entropy_file = /dev/urandom
|
||||
|
||||
; Set to {nocache,private,public} to determine HTTP caching aspects.
|
||||
session.cache_limiter = nocache
|
||||
|
||||
; Document expires after n minutes.
|
||||
session.cache_expire = 180
|
||||
|
||||
; use transient sid support if enabled by compiling with --enable-trans-sid.
|
||||
session.use_trans_sid = 1
|
||||
|
||||
url_rewriter.tags = "a=href,area=href,frame=src,input=src,form=fakeentry"
|
||||
|
||||
[MSSQL]
|
||||
; Allow or prevent persistent links.
|
||||
mssql.allow_persistent = On
|
||||
|
||||
; Maximum number of persistent links. -1 means no limit.
|
||||
mssql.max_persistent = -1
|
||||
|
||||
; Maximum number of links (persistent+non persistent). -1 means no limit.
|
||||
mssql.max_links = -1
|
||||
|
||||
; Minimum error severity to display.
|
||||
mssql.min_error_severity = 10
|
||||
|
||||
; Minimum message severity to display.
|
||||
mssql.min_message_severity = 10
|
||||
|
||||
; Compatability mode with old versions of PHP 3.0.
|
||||
mssql.compatability_mode = Off
|
||||
|
||||
; Valid range 0 - 2147483647. Default = 4096.
|
||||
;mssql.textlimit = 4096
|
||||
|
||||
; Valid range 0 - 2147483647. Default = 4096.
|
||||
;mssql.textsize = 4096
|
||||
|
||||
; Limits the number of records in each batch. 0 = all records in one batch.
|
||||
;mssql.batchsize = 0
|
||||
|
||||
; Use NT authentication when connecting to the server
|
||||
mssql.secure_connection = Off
|
||||
|
||||
; Specify max number of processes. Default = 25
|
||||
;mssql.max_procs = 25
|
||||
|
||||
[Assertion]
|
||||
; Assert(expr); active by default.
|
||||
;assert.active = On
|
||||
|
||||
; Issue a PHP warning for each failed assertion.
|
||||
;assert.warning = On
|
||||
|
||||
; Don't bail out by default.
|
||||
;assert.bail = Off
|
||||
|
||||
; User-function to be called if an assertion fails.
|
||||
;assert.callback = 0
|
||||
|
||||
; Eval the expression with current error_reporting(). Set to true if you want
|
||||
; error_reporting(0) around the eval().
|
||||
;assert.quiet_eval = 0
|
||||
|
||||
[Ingres II]
|
||||
; Allow or prevent persistent links.
|
||||
ingres.allow_persistent = On
|
||||
|
||||
; Maximum number of persistent links. -1 means no limit.
|
||||
ingres.max_persistent = -1
|
||||
|
||||
; Maximum number of links, including persistents. -1 means no limit.
|
||||
ingres.max_links = -1
|
||||
|
||||
; Default database (format: [node_id::]dbname[/srv_class]).
|
||||
ingres.default_database =
|
||||
|
||||
; Default user.
|
||||
ingres.default_user =
|
||||
|
||||
; Default password.
|
||||
ingres.default_password =
|
||||
|
||||
[Verisign Payflow Pro]
|
||||
; Default Payflow Pro server.
|
||||
pfpro.defaulthost = "test-payflow.verisign.com"
|
||||
|
||||
; Default port to connect to.
|
||||
pfpro.defaultport = 443
|
||||
|
||||
; Default timeout in seconds.
|
||||
pfpro.defaulttimeout = 30
|
||||
|
||||
; Default proxy IP address (if required).
|
||||
;pfpro.proxyaddress =
|
||||
|
||||
; Default proxy port.
|
||||
;pfpro.proxyport =
|
||||
|
||||
; Default proxy logon.
|
||||
;pfpro.proxylogon =
|
||||
|
||||
; Default proxy password.
|
||||
;pfpro.proxypassword =
|
||||
|
||||
[Sockets]
|
||||
; Use the system read() function instead of the php_read() wrapper.
|
||||
sockets.use_system_read = On
|
||||
|
||||
[com]
|
||||
; path to a file containing GUIDs, IIDs or filenames of files with TypeLibs
|
||||
;com.typelib_file =
|
||||
; allow Distributed-COM calls
|
||||
;com.allow_dcom = true
|
||||
; autoregister constants of a components typlib on com_load()
|
||||
;com.autoregister_typelib = true
|
||||
; register constants casesensitive
|
||||
;com.autoregister_casesensitive = false
|
||||
; show warnings on duplicate constat registrations
|
||||
;com.autoregister_verbose = true
|
||||
|
||||
[Printer]
|
||||
;printer.default_printer = ""
|
||||
|
||||
[mbstring]
|
||||
; internal/script encoding.
|
||||
; Some encoding cannot work as internal encoding.
|
||||
; (e.g. SJIS, BIG5, ISO-2022-*)
|
||||
;mbstring.internal_encoding = EUC-JP
|
||||
|
||||
; http input encoding.
|
||||
;mbstring.http_input = auto
|
||||
|
||||
; http output encoding. mb_output_handler must be
|
||||
; registered as output buffer to function
|
||||
;mbstring.http_output = SJIS
|
||||
|
||||
; automatic encoding detection order.
|
||||
; auto means
|
||||
;mbstring.detect_order = auto
|
||||
|
||||
; substitute_character used when character cannot be converted
|
||||
; one from another
|
||||
;mbstring.substitute_character = none;
|
||||
|
||||
; overload(replace) single byte functions by mbstring functions.
|
||||
; mail(), ereg(), etc are overloaded by mb_send_mail(), mb_ereg(),
|
||||
; etc.
|
||||
;mbstring.func_overload = No
|
||||
|
||||
[FrontBase]
|
||||
;fbsql.allow_persistent = On
|
||||
;fbsql.autocommit = On
|
||||
;fbsql.default_database =
|
||||
;fbsql.default_database_password =
|
||||
;fbsql.default_host =
|
||||
;fbsql.default_password =
|
||||
;fbsql.default_user = "_SYSTEM"
|
||||
;fbsql.generate_warnings = Off
|
||||
;fbsql.max_connections = 128
|
||||
;fbsql.max_links = 128
|
||||
;fbsql.max_persistent = -1
|
||||
;fbsql.max_results = 128
|
||||
;fbsql.batchSize = 1000
|
||||
|
||||
[Crack]
|
||||
; Modify the setting below to match the directory location of the cracklib
|
||||
; dictionary files. Include the base filename, but not the file extension.
|
||||
; crack.default_dictionary = "c:\php\lib\cracklib_dict"
|
||||
|
||||
; Local Variables:
|
||||
; tab-width: 4
|
||||
; End:
|
||||
@@ -1,48 +0,0 @@
|
||||
%define version @VERSION@
|
||||
%define so_version 4
|
||||
%define release 1
|
||||
|
||||
Name: php
|
||||
Summary: PHP: Hypertext Preprocessor
|
||||
Group: Development/Languages
|
||||
Version: %{version}
|
||||
Release: %{release}
|
||||
Copyright: The PHP license (see "LICENSE" file included in distribution)
|
||||
Source: http://www.php.net/version4/downloads/php-%{version}.tar.gz
|
||||
Icon: php.gif
|
||||
URL: http://www.php.net/
|
||||
Packager: PHP Group <group@php.net>
|
||||
|
||||
BuildRoot: /var/tmp/php-%{version}
|
||||
|
||||
%description
|
||||
PHP is an HTML-embedded scripting language. Much of its syntax is
|
||||
borrowed from C, Java and Perl with a couple of unique PHP-specific
|
||||
features thrown in. The goal of the language is to allow web
|
||||
developers to write dynamically generated pages quickly.
|
||||
|
||||
%prep
|
||||
|
||||
%setup
|
||||
|
||||
%build
|
||||
set -x
|
||||
./buildconf
|
||||
./configure --prefix=/usr --with-apxs \
|
||||
--enable-track-vars --disable-debug \
|
||||
--with-xml=shared \
|
||||
|
||||
# figure out configure options options based on what packages are installed
|
||||
# to override, use the OVERRIDE_OPTIONS environment variable. To add
|
||||
# extra options, use the OPTIONS environment variable.
|
||||
|
||||
#test rpm -q MySQL-devel >&/dev/null && OPTIONS="$OPTIONS --with-mysql=shared"
|
||||
#test rpm -q solid-devel >&/dev/null && OPTIONS="$OPTIONS --with-solid=shared,/home/solid"
|
||||
#test rpm -q postgresql-devel >&/dev/null && OPTIONS="$OPTIONS --with-pgsql=shared"
|
||||
test rpm -q expat >&/dev/null && OPTIONS="$OPTIONS --with-xml=shared"
|
||||
|
||||
if test "x$OVERRIDE_OPTIONS" = "x"; then
|
||||
./configure --prefix=/usr --with-apxs=$APXS $OPTIONS
|
||||
else
|
||||
./configure $OVERRIDE_OPTIONS
|
||||
fi
|
||||
-426
@@ -1,426 +0,0 @@
|
||||
<?php
|
||||
/*
|
||||
+----------------------------------------------------------------------+
|
||||
| PHP Version 4 |
|
||||
+----------------------------------------------------------------------+
|
||||
| Copyright (c) 1997-2002 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: Preston L. Bannister <pbannister@php.net> |
|
||||
| Sander Roobol <sander@php.net> |
|
||||
| (based on version by: Stig Bakken <ssb@fast.no>) |
|
||||
| (based on the PHP 3 test framework by Rasmus Lerdorf) |
|
||||
+----------------------------------------------------------------------+
|
||||
*/
|
||||
|
||||
/*
|
||||
|
||||
Require exact specification of PHP executable to test (no guessing!).
|
||||
|
||||
Die if any internal errors encountered in test script.
|
||||
|
||||
Regularized output for simpler post-processing of output.
|
||||
|
||||
Optionally output error lines indicating the failing test source and log
|
||||
for direct jump with MSVC or Emacs.
|
||||
|
||||
*/
|
||||
|
||||
/*
|
||||
* TODO:
|
||||
* - do not test PEAR components if base class and/or component class cannot be instanciated
|
||||
*/
|
||||
|
||||
set_time_limit(0);
|
||||
ob_implicit_flush();
|
||||
error_reporting(E_ALL);
|
||||
|
||||
if (ini_get('safe_mode')) {
|
||||
echo <<<SAFE_MODE_WARNING
|
||||
|
||||
+-----------------------------------------------------------+
|
||||
| ! WARNING ! |
|
||||
| You are running the test-suite with "safe_mode" ENABLED ! |
|
||||
| |
|
||||
| Chances are high that no test will work at all, |
|
||||
| depending on how you configured "safe_mode" ! |
|
||||
+-----------------------------------------------------------+
|
||||
|
||||
|
||||
SAFE_MODE_WARNING;
|
||||
}
|
||||
|
||||
// Don't ever guess at the PHP executable location.
|
||||
// Require the explicit specification.
|
||||
// Otherwise we could end up testing the wrong file!
|
||||
|
||||
if(isset($_ENV['TEST_PHP_EXECUTABLE'])) {
|
||||
$php = $_ENV['TEST_PHP_EXECUTABLE'];
|
||||
} else {
|
||||
error("environment variable TEST_PHP_EXECUTABLE must be set to specify PHP executable!");
|
||||
}
|
||||
|
||||
if(!@is_executable($php)) {
|
||||
error("invalid PHP executable specified by TEST_PHP_EXECUTABLE = " . $php);
|
||||
}
|
||||
|
||||
// Check whether a detailed log is wanted.
|
||||
|
||||
if(isset($_ENV['TEST_PHP_DETAILED'])) {
|
||||
define('DETAILED', $_ENV['TEST_PHP_DETAILED']);
|
||||
} else {
|
||||
define('DETAILED', 0);
|
||||
}
|
||||
|
||||
// Write test context information.
|
||||
|
||||
echo "
|
||||
=====================================================================
|
||||
CWD : " . getcwd() . "
|
||||
PHP : $php
|
||||
PHP_SAPI : " . PHP_SAPI . "
|
||||
PHP_VERSION : " . PHP_VERSION . "
|
||||
PHP_OS : " . PHP_OS . "
|
||||
INI actual : " . realpath(get_cfg_var('cfg_file_path')) . "
|
||||
INI wanted : " . realpath('php.ini-dist') . "
|
||||
=====================================================================
|
||||
";
|
||||
|
||||
// Make sure we are using the proper php.ini.
|
||||
|
||||
$php_ini = realpath("php.ini-dist");
|
||||
if(realpath(get_cfg_var('cfg_file_path')) != $php_ini) {
|
||||
error("php.ini-dist was not used!");
|
||||
}
|
||||
$php .= " -c $php_ini";
|
||||
|
||||
// Determine the tests to be run.
|
||||
|
||||
$test_to_run = array();
|
||||
$test_files = array();
|
||||
$test_results = array();
|
||||
|
||||
// If parameters given assume they represent selected tests to run.
|
||||
if (isset($argc) && $argc>1) {
|
||||
for ($i=1; $i<$argc; $i++) {
|
||||
$testfile = realpath($argv[$i]);
|
||||
$test_to_run[$testfile] = 1;
|
||||
}
|
||||
}
|
||||
|
||||
// Compile a list of all test files (*.phpt).
|
||||
$test_files = array();
|
||||
$module_of_test = array();
|
||||
find_files(getcwd());
|
||||
|
||||
function find_files($dir) {
|
||||
global $test_files, $module_of_test;
|
||||
|
||||
/* FIXME: this messes up if you unpack PHP in /ext/pear :) */
|
||||
if (ereg('/ext/([^/]+)/',"$dir/",$r)) {
|
||||
$module = $r[1];
|
||||
} else if (ereg('/pear/',"$dir/")) {
|
||||
$module = 'pear';
|
||||
} else {
|
||||
$module = '';
|
||||
}
|
||||
|
||||
$o = opendir($dir) or error("cannot open directory: $dir");
|
||||
while (($name = readdir($o))!==false) {
|
||||
if (is_dir("{$dir}/{$name}") && !in_array($name, array('.', '..', 'CVS'))) {
|
||||
find_files("{$dir}/{$name}");
|
||||
}
|
||||
|
||||
// Cleanup any left-over tmp files from last run.
|
||||
if (substr($name, -4)=='.tmp') {
|
||||
@unlink("$dir/$name");
|
||||
continue;
|
||||
}
|
||||
|
||||
// Otherwise we're only interested in *.phpt files.
|
||||
if (substr($name, -5)=='.phpt') {
|
||||
$testfile = realpath("{$dir}/{$name}");
|
||||
$test_files[] = $testfile;
|
||||
// $module_of_test[$testfile] = $module;
|
||||
}
|
||||
}
|
||||
|
||||
closedir($o);
|
||||
}
|
||||
|
||||
// Run only selected tests, if specified.
|
||||
if (count($test_to_run)) {
|
||||
echo "Running selected tests.\n";
|
||||
foreach($test_to_run AS $name=>$runnable) {
|
||||
echo "test: $name runnable: $runnable\n";
|
||||
if ($runnable) {
|
||||
$test_results[$name] = run_test($php,$name);
|
||||
}
|
||||
}
|
||||
exit(0);
|
||||
}
|
||||
|
||||
sort($test_files);
|
||||
|
||||
$start_time = time();
|
||||
|
||||
echo "TIME START " . date('Y-m-d H:i:s', $start_time) . "
|
||||
=====================================================================
|
||||
";
|
||||
|
||||
$path_current = '';
|
||||
foreach ($test_files as $name) {
|
||||
|
||||
$path = dirname($name);
|
||||
if ($path_current != $path) {
|
||||
$path_current = $path;
|
||||
echo " entering directory $path\n";
|
||||
}
|
||||
|
||||
$test_results[$name] = run_test($php,$name);
|
||||
}
|
||||
|
||||
$end_time = time();
|
||||
|
||||
// Summarize results
|
||||
|
||||
if (0 == count($test_results)) {
|
||||
echo "No tests were run.\n";
|
||||
return;
|
||||
}
|
||||
|
||||
$n_total = count($test_results);
|
||||
$sum_results = array('PASSED'=>0, 'SKIPPED'=>0, 'FAILED'=>0);
|
||||
foreach ($test_results as $v) {
|
||||
$sum_results[$v]++;
|
||||
}
|
||||
$percent_results = array();
|
||||
while (list($v,$n) = each($sum_results)) {
|
||||
$percent_results[$v] = (100.0 * $n) / $n_total;
|
||||
}
|
||||
|
||||
echo "
|
||||
=====================================================================
|
||||
TIME END " . date('Y-m-d H:i:s', $end_time) . "
|
||||
=====================================================================
|
||||
TEST RESULT SUMMARY
|
||||
---------------------------------------------------------------------
|
||||
Number of tests : " . sprintf("%4d",$n_total) . "
|
||||
Tests skipped : " . sprintf("%4d (%2.1f%%)",$sum_results['SKIPPED'],$percent_results['SKIPPED']) . "
|
||||
Tests failed : " . sprintf("%4d (%2.1f%%)",$sum_results['FAILED'],$percent_results['FAILED']) . "
|
||||
Tests passed : " . sprintf("%4d (%2.1f%%)",$sum_results['PASSED'],$percent_results['PASSED']) . "
|
||||
Time taken : " . sprintf("%4d seconds", $end_time - $start_time) . "
|
||||
=====================================================================
|
||||
";
|
||||
|
||||
//
|
||||
// Write the given text to a temporary file, and return the filename.
|
||||
//
|
||||
|
||||
function save_text($filename,$text) {
|
||||
$fp = @fopen($filename,'w')
|
||||
or error("Cannot open file '" . $filename . "' (save_text)");
|
||||
fwrite($fp,$text);
|
||||
fclose($fp);
|
||||
if (1 < DETAILED) echo "
|
||||
FILE $filename {{{
|
||||
$text
|
||||
}}}
|
||||
";
|
||||
}
|
||||
|
||||
//
|
||||
// Write an error in a format recognizable to Emacs or MSVC.
|
||||
//
|
||||
|
||||
function error_report($testname,$logname,$tested)
|
||||
{
|
||||
$testname = realpath($testname);
|
||||
$logname = realpath($logname);
|
||||
switch (strtoupper(getenv('TEST_PHP_ERROR_STYLE'))) {
|
||||
case 'MSVC':
|
||||
echo $testname . "(1) : $tested\n";
|
||||
echo $logname . "(1) : $tested\n";
|
||||
break;
|
||||
case 'EMACS':
|
||||
echo $testname . ":1: $tested\n";
|
||||
echo $logname . ":1: $tested\n";
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
//
|
||||
// Run an individual test case.
|
||||
//
|
||||
|
||||
function run_test($php,$file)
|
||||
{
|
||||
if (DETAILED) echo "
|
||||
=================
|
||||
TEST $file
|
||||
";
|
||||
|
||||
// Load the sections of the test file.
|
||||
|
||||
$section_text = array(
|
||||
'TEST' => '(unnamed test)',
|
||||
'SKIPIF' => '',
|
||||
'GET' => '',
|
||||
);
|
||||
|
||||
$fp = @fopen($file, "r")
|
||||
or error("Cannot open test file: $file");
|
||||
|
||||
$section = '';
|
||||
while (!feof($fp)) {
|
||||
$line = fgets($fp);
|
||||
|
||||
// Match the beginning of a section.
|
||||
if (ereg('^--([A-Z]+)--',$line,$r)) {
|
||||
$section = $r[1];
|
||||
$section_text[$section] = '';
|
||||
continue;
|
||||
}
|
||||
|
||||
// Add to the section text.
|
||||
$section_text[$section] .= $line;
|
||||
}
|
||||
fclose($fp);
|
||||
|
||||
$tested = trim($section_text['TEST']).' ('.basename($file).')';
|
||||
|
||||
$tmp = realpath(dirname($file));
|
||||
$tmp_skipif = $tmp.uniqid('/phpt.');
|
||||
$tmp_file = $tmp.uniqid('/phpt.');
|
||||
$tmp_post = $tmp.uniqid('/phpt.');
|
||||
|
||||
@unlink($tmp_skipif);
|
||||
@unlink($tmp_file);
|
||||
@unlink($tmp_post);
|
||||
|
||||
// Reset environment from any previous test.
|
||||
|
||||
putenv("REDIRECT_STATUS=");
|
||||
putenv("QUERY_STRING=");
|
||||
putenv("PATH_TRANSLATED=");
|
||||
putenv("SCRIPT_FILENAME=");
|
||||
putenv("REQUEST_METHOD=");
|
||||
putenv("CONTENT_TYPE=");
|
||||
putenv("CONTENT_LENGTH=");
|
||||
|
||||
// Check if test should be skipped.
|
||||
|
||||
if (trim($section_text['SKIPIF'])) {
|
||||
save_text($tmp_skipif, $section_text['SKIPIF']);
|
||||
$output = `$php $tmp_skipif`;
|
||||
@unlink($tmp_skipif);
|
||||
if(trim($output)=='skip') {
|
||||
echo "SKIP $tested\n";
|
||||
return 'SKIPPED';
|
||||
}
|
||||
}
|
||||
|
||||
// We've satisfied the preconditions - run the test!
|
||||
|
||||
save_text($tmp_file,$section_text['FILE']);
|
||||
$query_string = trim($section_text['GET']);
|
||||
|
||||
putenv("REDIRECT_STATUS=1");
|
||||
putenv("QUERY_STRING=$query_string");
|
||||
putenv("PATH_TRANSLATED=$tmp_file");
|
||||
putenv("SCRIPT_FILENAME=$tmp_file");
|
||||
|
||||
if (!empty($section_text['POST'])) {
|
||||
|
||||
$post = trim($section_text['POST']);
|
||||
save_text($tmp_post,$post);
|
||||
$content_length = strlen($post);
|
||||
|
||||
putenv("REQUEST_METHOD=POST");
|
||||
putenv("CONTENT_TYPE=application/x-www-form-urlencoded");
|
||||
putenv("CONTENT_LENGTH=$content_length");
|
||||
|
||||
$cmd = "$php -f $tmp_file 2>&1 < $tmp_post";
|
||||
|
||||
} else {
|
||||
|
||||
putenv("REQUEST_METHOD=GET");
|
||||
putenv("CONTENT_TYPE=");
|
||||
putenv("CONTENT_LENGTH=");
|
||||
|
||||
$cmd = "$php -f $tmp_file 2>&1";
|
||||
|
||||
}
|
||||
|
||||
if (DETAILED) echo "
|
||||
CONTENT_LENGTH = " . getenv("CONTENT_LENGTH") . "
|
||||
CONTENT_TYPE = " . getenv("CONTENT_TYPE") . "
|
||||
PATH_TRANSLATED = " . getenv("PATH_TRANSLATED") . "
|
||||
QUERY_STRING = " . getenv("QUERY_STRING") . "
|
||||
REDIRECT_STATUS = " . getenv("REDIRECT_STATUS") . "
|
||||
REQUEST_METHOD = " . getenv("REQUEST_METHOD") . "
|
||||
SCRIPT_FILENAME = " . getenv("SCRIPT_FILENAME") . "
|
||||
COMMAND $cmd
|
||||
";
|
||||
|
||||
$out = `$cmd`;
|
||||
|
||||
@unlink($tmp_post);
|
||||
@unlink($tmp_file);
|
||||
|
||||
// Does the output match what is expected?
|
||||
|
||||
$output = trim(preg_replace('/^(..+\n)+\n/','',$out));
|
||||
$wanted = trim($section_text['EXPECT']);
|
||||
|
||||
$output = preg_replace('/\r\n/',"\n",$output);
|
||||
$wanted = preg_replace('/\r\n/',"\n",$wanted);
|
||||
|
||||
$ok = (0 == strcmp($output,$wanted));
|
||||
if ($ok) {
|
||||
echo "PASS $tested\n";
|
||||
return 'PASSED';
|
||||
}
|
||||
|
||||
// Test failed so we need to report details.
|
||||
|
||||
echo "FAIL $tested\n";
|
||||
|
||||
$logname = ereg_replace('\.phpt$','.log',$file);
|
||||
$log = fopen($logname,'w')
|
||||
or error("Cannot create test log - $logname");
|
||||
|
||||
fwrite($log,"
|
||||
---- EXPECTED OUTPUT
|
||||
$wanted
|
||||
---- ACTUAL OUTPUT
|
||||
$output
|
||||
---- FAILED
|
||||
");
|
||||
fclose($log);
|
||||
|
||||
error_report($file,$logname,$tested);
|
||||
|
||||
return 'FAILED';
|
||||
}
|
||||
|
||||
function error($message) {
|
||||
echo "ERROR: {$message}\n";
|
||||
exit(1);
|
||||
}
|
||||
|
||||
/*
|
||||
* Local variables:
|
||||
* tab-width: 4
|
||||
* c-basic-offset: 4
|
||||
* indent-tabs-mode: t
|
||||
* End:
|
||||
*/
|
||||
?>
|
||||
@@ -1,32 +0,0 @@
|
||||
BEGIN {
|
||||
mode=0
|
||||
sources=""
|
||||
}
|
||||
|
||||
mode == 0 && /^LTLIBRARY_SOURCES.*\\$/ {
|
||||
if (match($0, "[^=]*$")) {
|
||||
sources=substr($0, RSTART, RLENGTH-1)
|
||||
}
|
||||
mode=1
|
||||
next
|
||||
}
|
||||
|
||||
mode == 0 && /^LTLIBRARY_SOURCES.*/ {
|
||||
if (match($0, "[^=]*$")) {
|
||||
sources=substr($0, RSTART, RLENGTH)
|
||||
}
|
||||
}
|
||||
|
||||
mode == 1 && /.*\\$/ {
|
||||
sources=sources substr($0, 0, length - 1)
|
||||
next
|
||||
}
|
||||
|
||||
mode == 1 {
|
||||
sources=sources $0
|
||||
mode=0
|
||||
}
|
||||
|
||||
END {
|
||||
print sources
|
||||
}
|
||||
@@ -1,7 +0,0 @@
|
||||
#! /bin/sh
|
||||
|
||||
if test -n "$1"; then
|
||||
flags="DISTNAME=$1"
|
||||
fi
|
||||
|
||||
${MAKE:-make} $flags -f build/build.mk snapshot
|
||||
@@ -1 +0,0 @@
|
||||
timestamp
|
||||
-113
@@ -1,113 +0,0 @@
|
||||
#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
|
||||
Reference in new issue
Block a user