PHP free e-books, free codes, free scripts, free downloads

What is Self-XSS attack

2011-11-16T21:51:00.000-08:00

Recently hackers attacked facebook by injecting porn images and videos in to the users account.Facebook said, it is a Self-XSS attack.

The Self XSS attack is a computer securtiy vulnerability, mostly used to attack the web applications by injecting client side script (Java Script, VB Script etc..) into web pages viewed by other users.

The below examples will be giving an overall idea about how a client side script can inject,

For example enter the code into the web browser

javascript:alert('I am XSS');

This is will show a pop up with "I am XSS".

Like this a hacker can inject malicious codes into the browser to steal confidential data, cookies, redirect to other sites etc...

To get all the cookies informations, execute the below code in the browser

javascript:alert("Cookies:"+document.cookies+" "+"\n I am XSS");

The above codes would not be doing other than displaying the datas, but a hacker can
inject powerfull malicious codes to destroy the user informations.

Download PDF:

1) A Study of Malicious Attacks on Facebook

2) http://www.blackhat.com/presentations/bh-usa-06/BH-US-06-Hoffman.pdf

3) Cross-Site Scripting XSS

4) http://sun.cs.ucdavis.edu/papers/esorics09_xssworm.pdf

ViewVC or ViewCVS

2011-11-16T04:46:00.000-08:00

It was calling as ViewCVS, but it got changed to ViewVC.The open source tool is giving an browser interface to view the contents of SVN and CVS.
This generates HTML to present directory, revision and logs. ViewVC is written in python and the parameters can be modified directly in a URL by using a REST style interface.

The below items are some of the additional features of ViewVC:

Support for filesystem-accessible CVS and Subversion repositories.
Support for path-based authorization, including parsing and honoring Subversion authz configuration files.
RSS feed generation for tracking changes to repositories or individual items within repositories.
Individually configurable virtual host support.
Line-based annotation/blame display.
Revision graph capabilities (via integration with CvsGraph) (CVS only).
Syntax highlighting support.
Bonsai-like repository query facilities.
Template-driven output generation.
Colorized, side-by-side differences.
Tarball generation (by tag/branch for CVS, by revision for Subversion).
Localization support based on the Accept-Language request header.
Ability to run either as CGI script or as a standalone server.
Regexp-based file searching.
INI-like configuration file (as opposed to requiring actual code tweaks)

The authentication and auhtorization can be set while accessing the repositories using ViewVC.
But the question is how can we restrict individual users to access their CVS or SVN repositories.

The below URLs gives an ideas:

http://www.viewvc.org/faq.html#authz-support

http://svn-access-mana.sourceforge.net/#inst_web_viewvc

Download PDFs:

1) http://svnbook.red-bean.com/en/1.5/svn-book.pdf

2) http://micro.stanford.edu/mediawiki/images/0/04/Howto_istall_SVN_Fedora.pdf

3) http://www.docbook.org/docs/howto/howto.pdf

4) http://www.shrubbery.net/rancid/RhysEvans_overview_0.3.pdf

5) http://micro.stanford.edu/mediawiki/images/9/9b/Howto_istall_SVN_CentOS.pdf

6) http://wsmoak.net/subversion/demo/viewvc.html

7) http://en.wikipedia.org/wiki/ViewVC

Advantages of Becoming a PHP Zend Certified Engineer - ZCE

2011-11-15T00:48:00.000-08:00

ZCE is the #1 php certification available in the market.
The certified person gets a good profile weightage.

1) Differentiate yourself from other job seekers
2) Increases your value while salary review
3) Easily shortlisted your CV/Resume
4) Gets a good recognition from the employer
5) Lists in the Zens's PHP Yellow pages
http://www.zend.com/en/store/education/certification/yellow-pages.php

Nearly 70 questions will be asked for the ZCE exam.
The questions will be picked up randomly.There will be multiple type questions as well as the description type questions.

Nearly one month of thorough training or self study is needed for the exam.
The below links are very much useful for the beginners.

http://www.zend.com/en/services/certification/

http://www.zend.com/en/services/training/course-catalog/certification

Visit the URL to get the exam topics http://www.zend.com/en/services/certification/php-5-certification/

Using session in PHP

2008-11-06T07:57:00.000-08:00

Keeping in mind the fact that Internet is a stateless platform and every request for a web page is treated as unique, there is a serious need of a tool to maintain the state. Otherwise, it will be a messy situation to keep track of requests made by a particular user. The good news is that use of PHP session serves the solution to this problem. This session variable is of great importance for web applications like shopping carts and is considered as equivalent to cookies, other significant way of maintaining the state.

What Is PHP Session Capable Of

PHP session is capable of storing the information in the form of session variables, in order to handle the ever-increasing traffic on a website. For instance, consider a shopping website, with products scattered in different categories and different pages. In such a situation, a user may switch from one page t another and keep on adding products from different pages to his or her shopping cart.

Memcache

2008-11-06T07:54:00.000-08:00

Memcache module provides handy procedural and object oriented interface to memcached, highly effective caching daemon, which was especially designed to decrease database load in dynamic web applications.

The Memcache module also provides a session handler (memcache).

More information about memcached can be found at » http://www.danga.com/memcached/.

Below is one example

$memcache = new Memcache;
$memcache->connect('localhost', 11211) or die ("Could not connect");

$version = $memcache->getVersion();
echo "Server's version: ".$version."
\n";

$tmp_object = new stdClass;
$tmp_object->str_attr = 'test';
$tmp_object->int_attr = 123;

$memcache->set('key', $tmp_object, false, 10) or die ("Failed to save data at the server");
echo "Store data in the cache (data will expire in 10 seconds)
\n";

$get_result = $memcache->get('key');
echo "Data from the cache:
\n";

var_dump($get_result);

?>

PHP Design Patterns

2008-05-30T21:40:00.000-07:00

Patterns are ways to describe best practices and good designs. They show a flexible solution to common programming problems.

* Factory Patterns: The Factory pattern allows for the instantiation of objects at runtime. It is called a Factory Pattern since it is responsible for "manufacturing" an object. A Parameterized Factory receives the name of the class to instantiate as argument.

* Singleton Patterns: The Singleton pattern applies to situations in which there needs to be a single instance of a class. The most common example of this is a database connection. Implementing this pattern allows a programmer to make this single instance easily accessible by many other objects.
i got this good stuff from a newly coming website on PHP, http://www.e-php.info

metaphone — Calculate the metaphone key of a string

2008-05-24T22:30:00.000-07:00

Description
string metaphone ( string $str [, int $phones ] )

Calculates the metaphone key of str .

Similar to soundex() metaphone creates the same key for similar sounding words. It's more accurate than soundex() as it knows the basic rules of English pronunciation. The metaphone generated keys are of variable length.

Metaphone was developed by Lawrence Philips . It is described in ["Practical Algorithms for Programmers", Binstock & Rex, Addison Wesley, 1995].

quotemeta — Quote meta characters

2008-05-24T22:24:00.000-07:00

Description

string quotemeta ( string $str )

Returns a version of str with a backslash character (\) before every character that is among these:

. \ + * ? [ ^ ] ( $ )


  Returns the string with meta characters quoted.
This function is
binary-safe.

parse_str — Parses the string into variables

2008-05-24T22:10:00.000-07:00

str: The input string.
arr: If the second parameter arr is present, variables are stored in this variable as array elements instead.

void parse_str ( string $str [, array &$arr ] )

No value is returned.

$str = "first=value&arr[]=foo+bar&arr[]=baz";
parse_str($str);
echo $first;  // value
echo $arr[0]; // foo bar
echo $arr[1]; // baz

parse_str($str, $output);
echo $output['first'];  // value
echo $output['arr'][0]; // foo bar
echo $output['arr'][1]; // baz

?>

sha1 — Calculate the sha1 hash of a string

2008-05-24T22:04:00.000-07:00

string sha1 ( string $str [, bool $raw_output ] )
Returns the sha1 hash as a string.

 $str = 'apple';

if (sha1($str) === 'd0be2dc421be4fcd0172e5afceea3970e2f3d940') {
    echo "Would you like a green or red apple?";
    exit;
}
?>

array_values — Return all the values of an array

2008-02-21T09:29:00.002-08:00

Description

array array_values ( array $input )

array_values() returns all the values from the input array and indexes numerically the array.

Example#1 array_values() example

 $array = array("size" => "XL", "color" => "gold");
print_r(array_values($array));
?>

The above example will output:

Array
(
   [0] => XL
   [1] => gold
)

array_flip — Exchanges all keys with their associated values in an array

2008-02-21T09:29:00.001-08:00

Description

array array_flip ( array $trans )

array_flip() returns an array in flip order, i.e. keys from trans become values and values from trans become keys.

Note that the values of trans need to be valid keys, i.e. they need to be either integer or string. A warning will be emitted if a value has the wrong type, and the key/value pair in question will not be flipped.

If a value has several occurrences, the latest key will be used as its values, and all others will be lost.

Parameters

trans: An array of key/value pairs to be flipped.

Return Values

Returns the flipped array on success and FALSE on failure.

Examples

Example#1 array_flip() example

 $trans = array_flip($trans);
$original = strtr($str, $trans);
?>

Example#2 array_flip() example : collision

 $trans = array("a" => 1, "b" => 1, "c" => 2);
$trans = array_flip($trans);
print_r($trans);
?>

now $trans is:

Array
(
   [1] => b
   [2] => c
)

array_walk — Apply a user function to every member of an array

2008-02-21T09:26:00.000-08:00

Description

bool array_walk ( array &$array , callback $funcname [, mixed $userdata ] )

Returns TRUE on success or FALSE on failure.

Applies the user-defined function funcname to each element of the array array. Typically, funcname takes on two parameters. The array parameter's value being the first, and the key/index second. If the optional userdata parameter is supplied, it will be passed as the third parameter to the callback funcname .

If function funcname requires more parameters than given to it, an error of level E_WARNING will be generated each time array_walk() calls funcname . These warnings may be suppressed by prepending the PHP error operator @ to the array_walk() call, or by using error_reporting().

Note: If funcname needs to be working with the actual values of the array, specify the first parameter of funcname as a reference. Then, any changes made to those elements will be made in the original array itself.

Note: Passing the key and userdata to funcname was added in 4.0.0

array_walk() is not affected by the internal array pointer of array . array_walk() will walk through the entire array regardless of pointer position.

Users may not change the array itself from the callback function. e.g. Add/delete elements, unset elements, etc. If the array that array_walk() is applied to is changed, the behavior of this function is undefined, and unpredictable.

Example#1 array_walk() example

 $fruits = array("d" => "lemon", "a" => "orange", "b" => "banana", "c" => "apple");

function test_alter(&$item1, $key, $prefix)
{
    $item1 = "$prefix: $item1";
}

function test_print($item2, $key)
{
    echo "$key. $item2
\n";
}

echo "Before ...:\n";
array_walk($fruits, 'test_print');

array_walk($fruits, 'test_alter', 'fruit');
echo "... and after:\n";

array_walk($fruits, 'test_print');
?>

The above example will output:

Before ...:
d. lemon
a. orange
b. banana
c. apple
... and after:
d. fruit: lemon
a. fruit: orange
b. fruit: banana
c. fruit: apple

readfile — Outputs a file

2008-02-20T09:38:00.000-08:00

Description

int readfile ( string $filename [, bool $use_include_path [, resource $context ]] )

Reads a file and writes it to the output buffer.

Parameters

filename: The filename being read.
use_include_path: You can use the optional second parameter and set it to TRUE, if you want to search for the file in the include_path, too.
context: A context stream resource.

Return Values

Returns the number of bytes read from the file. If an error occurs, FALSE is returned and unless the function was called as @readfile(), an error message is printed.


session_cache_limiter('none'); //*Use before session_start()
session_start();

$file = 'ASDFGgg.pdf';
_Download("files_dir/".$file, $file);

function _Download($f_location,$f_name){
     header ("Cache-Control: must-revalidate, post-check=0, pre-check=0");
    header('Content-Description: File Transfer');
    header('Content-Type: application/octet-stream');
    header('Content-Length: ' . filesize($f_location));
    header('Content-Disposition: attachment; filename=' . basename($f_name));
    readfile($f_location);
 }

?>

is_uploaded_file — Tells whether the file was uploaded via HTTP POST

2008-02-20T09:37:00.000-08:00

Description

bool is_uploaded_file ( string $filename )

Returns TRUE if the file named by filename was uploaded via HTTP POST. This is useful to help ensure that a malicious user hasn't tried to trick the script into working on files upon which it should not be working--for instance, /etc/passwd.

This sort of check is especially important if there is any chance that anything done with uploaded files could reveal their contents to the user, or even to other users on the same system.

For proper working, the function is_uploaded_file() needs an argument like $_FILES['userfile']['tmp_name'], - the name of the uploaded file on the clients machine $_FILES['userfile']['name'] does not work.

Parameters

filename: The filename being checked.

Return Values

Returns TRUE on success or FALSE on failure.

 
if (is_uploaded_file($_FILES['userfile']['tmp_name'])) {
   echo "File ". $_FILES['userfile']['name'] ." uploaded successfully.\n";
   echo "Displaying contents\n";
   readfile($_FILES['userfile']['tmp_name']);
} else {
   echo "Possible file upload attack: ";
   echo "filename '". $_FILES['userfile']['tmp_name'] . "'.";
}

?>

move_uploaded_file — Moves an uploaded file to a new location

2008-02-20T09:36:00.000-08:00

Description

bool move_uploaded_file ( string $filename , string $destination )

This function checks to ensure that the file designated by filename is a valid upload file (meaning that it was uploaded via PHP's HTTP POST upload mechanism). If the file is valid, it will be moved to the filename given by destination .

This sort of check is especially important if there is any chance that anything done with uploaded files could reveal their contents to the user, or even to other users on the same system.

Parameters

filename: The filename of the uploaded file.
destination: The destination of the moved file.

ob_end_flush — Flush (send) the output buffer and turn off output buffering

2008-02-20T09:34:00.000-08:00

Description

bool ob_end_flush ( void )

This function will send the contents of the topmost output buffer (if any) and turn this output buffer off. If you want to further process the buffer's contents you have to call ob_get_contents() before ob_end_flush() as the buffer contents are discarded after ob_end_flush() is called.

Note: This function is similar to ob_get_flush(), except that ob_get_flush() returns the buffer as a string.

Return Values

Returns TRUE on success or FALSE on failure. Reasons for failure are first that you called the function without an active buffer or that for some reason a buffer could not be deleted (possible for special buffer).

ob_start — Turn on output buffering

2008-02-20T09:32:00.000-08:00

Description

bool ob_start ([ callback $output_callback [, int $chunk_size [, bool $erase ]]] )

This function will turn output buffering on. While output buffering is active no output is sent from the script (other than headers), instead the output is stored in an internal buffer.

The contents of this internal buffer may be copied into a string variable using ob_get_contents(). To output what is stored in the internal buffer, use ob_end_flush(). Alternatively, ob_end_clean() will silently discard the buffer contents.

Warning

Some web servers (e.g. Apache) change the working directory of a script when calling the callback function. You can change it back by e.g. chdir(dirname($_SERVER['SCRIPT_FILENAME'])) in the callback function.

Output buffers are stackable, that is, you may call ob_start() while another ob_start() is active. Just make sure that you call ob_end_flush() the appropriate number of times. If multiple output callback functions are active, output is being filtered sequentially through each of them in nesting order.

Parameters

output_callback

An optional output_callback function may be specified. This function takes a string as a parameter and should return a string. The function will be called when ob_end_flush() is called, or when the output buffer is flushed to the browser at the end of the request. When output_callback is called, it will receive the contents of the output buffer as its parameter and is expected to return a new output buffer as a result, which will be sent to the browser. If the output_callback is not a callable function, this function will return FALSE.

If the callback function has two parameters, the second parameter is filled with a bit-field consisting of PHP_OUTPUT_HANDLER_START, PHP_OUTPUT_HANDLER_CONT and PHP_OUTPUT_HANDLER_END.

If output_callback returns FALSE original input is sent to the browser.

The output_callback parameter may be bypassed by passing a NULL value.

ob_end_clean(), ob_end_flush(), ob_clean(), ob_flush() and ob_start() may not be called from a callback function. If you call them from callback function, the behavior is undefined. If you would like to delete the contents of a buffer, return "" (a null string) from callback function. You can't even call functions using the output buffering functions like print_r($expression, true) or highlight_file($filename, true) from a callback function.

Note: In PHP 4.0.4, ob_gzhandler() was introduced to facilitate sending gz-encoded data to web browsers that support compressed web pages. ob_gzhandler() determines what type of content encoding the browser will accept and will return its output accordingly.

chunk_size

If the optional parameter chunk_size is passed, the buffer will be flushed after any output call which causes the buffer's length to equal or exceed chunk_size . Default value 0 means that the function is called only in the end, other special value 1 sets chunk_size to 4096.

md5 — Calculate the md5 hash of a string

2008-02-19T09:07:00.000-08:00

Calculates the MD5 hash of str using the » RSA Data Security, Inc. MD5 Message-Digest Algorithm, and returns that hash.
if ((md5($str) === '1f3870be274f6c49b3e31a0c6728957f') {
echo "Would you like a green or red apple?"; exit;}
?>

serialize — Generates a storable representation of a value

2007-10-24T18:37:00.001-07:00

string serialize ( mixed $value )

Generates a storable representation of a value

This is useful for storing or passing PHP values around without losing their type and structure.

To make the serialized string into a PHP value again, use unserialize().

Parameters

value

The value to be serialized. serialize() handles all types, except the resource-type. You can even serialize() arrays that contain references to itself. Circular references inside the array/object you are serialize()ing will also be stored. Any other reference will be lost.

When serializing objects, PHP will attempt to call the member function __sleep() prior to serialization. This is to allow the object to do any last minute clean-up, etc. prior to being serialized. Likewise, when the object is restored using unserialize() the __wakeup() member function is called.

Return Values

Returns a string containing a byte-stream representation of value that can be stored anywhere.

Examples

Example 2594. serialize() example

 // $session_data contains a multi-dimensional array with session
// information for the current user.  We use serialize() to store
// it in a database at the end of the request.

$conn = odbc_connect("webdb", "php", "chicken");
$stmt = odbc_prepare($conn,
      "UPDATE sessions SET data = ? WHERE id = ?");
$sqldata = array (serialize($session_data), $_SERVER['PHP_AUTH_USER']);
if (!odbc_execute($stmt, &$sqldata)) {
    $stmt = odbc_prepare($conn,
     "INSERT INTO sessions (id, data) VALUES(?, ?)");
    if (!odbc_execute($stmt, &$sqldata)) {
        /* Something went wrong.. */
    }
}
?>

move_uploaded_file — Moves an uploaded file to a new location

2007-10-24T18:36:00.001-07:00

bool move_uploaded_file ( string $filename, string $destination )

This sort of check is especially important if there is any chance that anything done with uploaded files could reveal their contents to the user, or even to other users on the same system.

Parameters

filename: The filename of the uploaded file.
destination: The destination of the moved file.

Return Values

If filename is not a valid upload file, then no action will occur, and move_uploaded_file() will return FALSE.

If filename is a valid upload file, but cannot be moved for some reason, no action will occur, and move_uploaded_file() will return FALSE. Additionally, a warning will be issued.

Notes

Note: move_uploaded_file() is both safe mode and open_basedir aware. However, restrictions are placed only on the destination path as to allow the moving of uploaded files in which filename may conflict with such restrictions. move_uploaded_file() ensures the safety of this operation by allowing only those files uploaded through PHP to be moved.

Warning

If the destination file already exists, it will be overwritten.

basename — Returns filename component of path

2007-10-24T18:34:00.000-07:00

string basename ( string $path [, string $suffix] )

Given a string containing a path to a file, this function will return the base name of the file.

Parameters

path

A path.

On Windows, both slash (/) and backslash (\) are used as directory separator character. In other environments, it is the forward slash (/).

suffix

If the filename ends in suffix this will also be cut off.

Return Values

Returns the base name of the given path.

 $path = "/home/httpd/html/index.php";
$file = basename($path);         // $file is set to "index.php"
$file = basename($path, ".php"); // $file is set to "index"
?>

glob-Find pathnames matching a pattern

2007-10-24T18:32:00.000-07:00

array glob ( string $pattern [, int $flags] )

The glob() function searches for all the pathnames matching pattern according to the rules used by the libc glob() function, which is similar to the rules used by common shells.

Parameters

pattern

The pattern. No tilde expansion or parameter substitution is done.

flags

Valid flags:

GLOB_MARK - Adds a slash to each item returned
GLOB_NOSORT - Return files as they appear in the directory (no sorting)
GLOB_NOCHECK - Return the search pattern if no files matching it were found
GLOB_NOESCAPE - Backslashes do not quote metacharacters
GLOB_BRACE - Expands {a,b,c} to match 'a', 'b', or 'c'
GLOB_ONLYDIR - Return only directory entries which match the pattern
GLOB_ERR - Stop on read errors (like unreadable directories), by default errors are ignored.

Return Values

Returns an array containing the matched files/directories, an empty array if no file matched or FALSE on error.

glob

2007-09-09T08:16:00.000-07:00

glob — Find pathnames matching a pattern

Description

array glob ( string $pattern [, int $flags] )

The glob() function searches for all the pathnames matching pattern according to the rules used by the libc glob() function, which is similar to the rules used by common shells.

Parameters

pattern

The pattern. No tilde expansion or parameter substitution is done.

flags

Valid flags:

GLOB_MARK - Adds a slash to each item returned
GLOB_NOSORT - Return files as they appear in the directory (no sorting)
GLOB_NOCHECK - Return the search pattern if no files matching it were found
GLOB_NOESCAPE - Backslashes do not quote metacharacters
GLOB_BRACE - Expands {a,b,c} to match 'a', 'b', or 'c'
GLOB_ONLYDIR - Return only directory entries which match the pattern
GLOB_ERR - Stop on read errors (like unreadable directories), by default errors are ignored.

Return Values

Returns an array containing the matched files/directories, an empty array if no file matched or FALSE on error.

ini_set()

2007-08-16T03:25:00.000-07:00

string ini_set ( string $varname, string $newvalue )
Sets the value of the given configuration option. The configuration option will keep this new value during the script's execution, and will be restored at the script's ending.

PHP Objects

2007-08-16T03:22:00.002-07:00

Basic Object-oriented programming functionality was added in PHP 3. Handling of objects was completely rewritten for PHP 5, allowing for better performance and more features. In previous versions of PHP, objects were handled like primitive types. The drawback of this method was that the whole object was copied when a variable was assigned, or passed as a parameter to a method. In the new approach, objects are referenced by handle, and not by value. PHP 5 introduced private and protected member variables and methods, along with abstract classes and abstract methods. It also introduced a standard way of declaring constructors and destructors similar to that of other object-oriented languages, such as C++, and an exception handling model similar to that of other programming languages.
The static method and class variable features in Zend Engine 2 do not work the way some expect. There is no virtual table feature in the engine, so the static variables are bound with a name at compile time instead of with a reference.
class foo extends bar
{
function __construct()
{
}
public static function thisstaticfunc()
{
}
}
The above very basic example shows how to define a class, foo, that inherits from class bar. Additionally, the function, mystaticfunc, is a public static function that is called with foo::thisstaticfunc();.
If the developer asks to create a copy of an object by using the reserved word clone, the Zend engine will check if a __clone() method has been defined or not. If not, it will call a default __clone() which will copy all of the object's properties. If a __clone() method is defined, then it will be responsible for setting the necessary properties in the created object. For convenience, the engine will supply a function that imports all of the properties from the source object, so that they can start with a by-value replica of the source object, and only override properties that need to be changed

PHP Data types

2007-08-16T03:22:00.001-07:00

PHP stores whole numbers in a platform-dependent range. This range is typically that of 32-bit signed integers. Integer variables can be assigned using decimal (positive and negative), octal and hexadecimal notations. Real numbers are also stored in a platform-specific range. They can be specified using floating point notation, or two forms of scientific notation.
PHP has a native Boolean type, named "boolean", similar to the native Boolean types in Java and C++. Using the Boolean type conversion rules, non-zero values can be interpreted as true and zero as false, as in Perl.
The null data type represents a variable that has no value. The only value in the null data type is NULL.
Variables of the "resource" type represent references to resources from external sources. These are typically created by functions from a particular extension, and can only be processed by functions from the same extension. Examples include file, image and database resources.
Arrays support both numeric and string indices, and are heterogeneous. Arrays can contain elements of any type that PHP can handle, including resources, objects, and even other arrays. Order is preserved in lists of values and in hashes with both keys and values, and the two can be intermingled

PHP Command-line scripting

2007-08-16T03:21:00.000-07:00

PHP also provides a command line interface SAPI for developing shell and desktop applications, daemons, log parsing, or other system administration tasks. PHP is increasingly used on the command line for tasks that have traditionally been the domain of Perl, Python, awk, or shell scripting

PHP Server-side scripting

2007-08-16T03:20:00.002-07:00

Originally designed to create dynamic web pages, PHP's principal focus is server-side scripting. While running the PHP parser with a web server and web browser, the PHP model can be compared to other server-side scripting languages such as Microsoft's ASP.NET system, Sun Microsystems' JavaServer Pages, mod_perl and the Ruby on Rails framework, as they all provide dynamic content to the client from a web server. To more directly compete with the "framework" approach taken by these systems, Zend is working on the Zend Framework - an emerging (as of June 2006) set of PHP building blocks and best practices; other PHP frameworks along the same lines include CakePHP, PRADO and Symfony.
The LAMP architecture has become popular in the Web industry as a way of deploying inexpensive, reliable, scalable, secure web applications. PHP is commonly used as the P in this bundle alongside Linux, Apache and MySQL, although the P can also refer to Python or Perl. PHP can be used with a large number of relational database management systems, runs on all of the most popular web servers and is available for many different operating systems. This flexibility means that PHP has a wide installation base across the Internet; over 19 million Internet domains are currently hosted on servers with PHP installed

PHP Usage

2007-08-16T03:20:00.001-07:00

PHP generally runs on a web server, taking PHP code as its input and creating Web pages as output. However, it can also be used for command-line scripting and client-side GUI applications. PHP can be deployed on most web servers and on almost every operating system and platform free of charge. The PHP Group also provides the complete source code for users to build, customize and extend for their own use.
PHP primarily acts as a filter. The PHP program takes input from a file or stream containing text and special PHP instructions and outputs another stream of data for display.
From PHP 4, the PHP parser compiles input to produce bytecode for processing by the Zend Engine, giving improved performance over its interpreter predecessor. PHP 5 uses the Zend Engine II.

PHP History

2007-08-16T03:19:00.000-07:00

PHP was written as a set of CGI binaries in the C programming language by the Danish/Greenlandic programmer Rasmus Lerdorf in 1994, to replace a small set of Perl scripts he had been using to maintain his personal homepage.[4] Lerdorf initially created PHP to display his résumé and to collect certain data, such as how much traffic his page was receiving. Personal Home Page Tools was publicly released on 8 June 1995 after Lerdorf combined it with his own Form Interpreter to create PHP/FI (this release is considered PHP version 2).[5]
Zeev Suraski and Andi Gutmans, two Israeli developers at the Technion IIT, rewrote the parser in 1997 and formed the base of PHP 3, changing the language's name to the recursive initialism PHP: Hypertext Preprocessor. The development team officially released PHP/FI 2 in November 1997 after months of beta testing. Public testing of PHP 3 began and the official launch came in June 1998. Suraski and Gutmans then started a new rewrite of PHP's core, producing the Zend Engine in 1999.[6] They also founded Zend Technologies in Ramat Gan, Israel, which actively manages the development of PHP.
In May 2000, PHP 4, powered by the Zend Engine 1.0, was released. The most recent update released by The PHP Group, is for the older PHP version 4 code branch which, as of May 2007, is up to version 4.4.7. PHP 4 will be supported by security updates until 8 August 2008[7].
On July 13, 2004, PHP 5 was released powered by the new Zend Engine II. PHP 5 included new features such as:[8]
Improved support for object-oriented programming
The PHP Data Objects extension, which defines a lightweight and consistent interface for accessing databases
Performance enhancements
Better support for MySQL
Embedded support for SQLite
Integrated SOAP support
Data iterators
Error handling via exceptions