PHP Hypertext Preprocessor

[PHP Classes] : Simpled thumbnail

2011-07-03T21:53:00.000-07:00

class: Simpled thumbnail

Class:

	Simpled thumbnail
	This class support forum

Short description:

Create thumbnails by cropping or resizing an image

Groups:

PHP 5

Graphics

Supplied by:

Roman

Detailed description:

This class can create thumbnails by cropping or resizing an image.

It can open an image from a file or string in GIF, JPEG or PNG formats and creates a thumbnail image with given dimensions by either resizing the image or cropping it.

The resulting image can be saved to a file or displayed as the current script output.

[PHP Classes] Added a new class: Chinese Character Conversion

2011-04-26T17:31:00.000-07:00

Short description:

Convert between traditional and simplified Chinese

Groups:

Localization

PHP 5

Text processing

Supplied by:

yinsee

Detailed description:

This class can convert text between traditional and simplified Chinese.

It can take a string with Chinese text encoded in UTF-8 and converts it between simplified and traditional Chinese, and vice-versa.

[PHP Classes] Added a new class: PID process check

2011-04-26T17:30:00.000-07:00

Short description:

Check if a PHP script is running using PID files

Groups:

PHP 5

Unix

Console

Windows

Supplied by:

Camilo Sperberg

Detailed description:

This class can check if a PHP script is running using PID files.

It looks at a given directory to see if it exists a process identifier file with the number of the current script process.

If the file exists, the class can call a Windows COM object or send a POSIX signal under a Linux/Unix system to determine if a process is running.

If the script is not yet running, the class creates the PID file and stores process number in it.

[PHP Classes] Added a new class: Binary Array

2011-04-19T23:19:00.000-07:00

Short description:

Manipulate compact arrays of integers with strings

Groups:

PHP 5

Data types

Supplied by:

Auslarrie Popier

Detailed description:

This package can manipulate compact arrays of integers with strings.

It provides several classes that implement the array access interface to store integer values of fixed length in strings of data.

Currently it provides classes for storing arrays of 8, 16, 32 and 64 bit integers.

[PHP Classes] Added a new class: SaffRequest

2011-04-17T18:10:00.000-07:00

Class:

	Saff Request
	This class support forum

Short description:

Retrieve the current HTTP request variables

Groups:

HTTP

PHP 5

Supplied by:

Zulfugar Ismayilzadeh

Detailed description:

This class can retrieve the current HTTP request variables.

It can retrieve the values of HTTP POST, GET, FILES and REQUEST variables.

The class also can filter request variables all at once and return an array of request variables that match a given regular expression.

[PHP Classes] Added a new class: XML-Writer

2011-04-17T18:08:00.000-07:00

Class:

	XML-Writer
	This class support forum

Short description:

Write XML documents to files

Groups:

XML

PHP 5

Files and Folders

Supplied by:

giulio

Detailed description:

This class can write XML documents to files.

It can open a given file and writes XML tags and data to it.

The class can write XML header tags, open and close tags, single elements with tag and data, and lists of elements from an associative array.

[PHP Classes] Innovation Award results of March of 2011

2011-04-01T19:09:00.000-07:00

[PHP Classes] Added a new class: Simple Zend View XSLT

2011-03-31T23:39:00.001-07:00

Class:

	Simple Zend View XSLT
	This class support forum

Short description:

Generate Zend framework view output with XSLT

Groups:

XML

PHP 5

Templates

Supplied by:

Kirill Shvakov

Detailed description:

This class can generate Zend framework view output with XSLT.

It extends the Zend framework view abstract class to generate view output using an XSLT template.

[PHP Classes] Added a new class: Plinq

2011-03-31T00:13:00.000-07:00

Class:

	Plinq
	This class support forum

Short description:

Query information in arrays using LINQ language

Groups:

PHP 5

Data types

Supplied by:

A. Çetin

Detailed description:

This class can query information in arrays using LINQ (language-integrated query) language.

It can traverse arrays and perform several types of operations defined programmatically.

Currently it can match array elements that satisfy a given condition, skip a given number of elements, get a given number of the first elements, compute the maximum, minumum and average of element values, sort elements,
append elements, etc..

[PHP Classes] PHP built-in Web server, PHP 5.3.6 and PHP.JS - Lately in PHP podcast episode 10

2011-03-30T04:38:00.001-07:00

A new post was published in PHP Classes blog

PHP built-in Web server, PHP 5.3.6 and PHP.JS - Lately in PHP podcast episode 10

Summary:

PHP is going to come with a built-in Web server, so you will no longer need Apache or any other Web server software to run PHP applications. This is the main topic discussed by Manuel Lemos and Ernani Joppert in the episode 10 of the Lately in PHP podcast.

They also discuss other topics of interest to the PHP world, like the PHP 5.3.6 security bug fix release and the PHP.JS project, which is a JavaScript library that provides the same functions of PHP to write JavaScript applications.

More...

Read the whole message and post your comments in the PHP Classes blog page.

If you like this post, do not forget to vote on it in Digg and in DZone, so more readers may know about this article. Use the buttons in the post page that says "digg it" to vote on the article on Digg and "zone it" to vote on DZone.

[PHP Classes] Added a new class: Cyber MySQL PDO

2011-03-30T00:09:00.001-07:00

Class:

	Cyber MySQL PDO
	This class support forum

Short description:

Execute database queries from parameters with PDO

Groups:

PHP 5

Databases

Supplied by:

Nicholas Oliveira

Detailed description:

This class can execute database queries from parameters with PDO.

It can take parameters that define tables, fields, values and conditions to execute SELECT, INSERT, UPDATE and delete queries.

The class uses the PDO extension to access any supported database.

[PHP Classes] Added a new class: ABG PHP To XLS

2011-03-29T00:13:00.001-07:00

[PHP Classes] Weekly newsletter of Monday - 2011-03-28

2011-03-28T07:19:00.000-07:00

[PHP Classes] Added a new class: Persian Calendar date function

2011-03-27T23:58:00.001-07:00

[PHP Classes] Added a new class: Similarities Finder

2011-03-27T00:07:00.001-07:00

[PHP Classes] Added a new class: Page Header

2011-03-25T20:12:00.001-07:00

[PHP Classes] Added a new class: Debugging Made Easy

2011-03-24T23:12:00.001-07:00

[PHP Classes] Added a new class: Leopard Validator

2011-03-24T00:23:00.001-07:00

[PHP Classes] Added a new class: cCaptcha

2011-03-24T00:09:00.001-07:00

[PHP Classes] The Fastest Ways to Deliver Email in PHP

2011-03-23T11:07:00.001-07:00

[PHP Classes] Added a new class: Estoy Database system

2011-03-23T00:22:00.001-07:00

[PHP Classes] Added a new class: NYOS_ExcelWriter_simple

2011-03-23T00:08:00.001-07:00

ArrayQry

2011-03-20T06:11:00.000-07:00

ArrayQry

Short description:

Execute MySQL database queries using arrays

Groups:

Databases

Supplied by:

Mark Berube

Detailed description:

This class can execute MySQL database queries using arrays.

It can connect to a MySQL database and execute SELECT queries retrieving the results as associative arrays.

The class can also execute INSERT or UPDATE queries taking arrays of field values. It can also execute DELETE queries.

Hijri To Gregorian Date Convert

2011-03-20T06:10:00.000-07:00

Hijri To Gregorian Date Convert

Short description:

Convert dates between Gregorian to Hijri calendars

Groups:

Time and Date

Supplied by:

Layth A. Ibraheem

Detailed description:

This class can convert dates between Gregorian to Hijri calendars.

It can take a date in the Gregorian calendar and converts it to Hijri calendar.

The class can also do the opposite, i.e., convert dates between the Hijri to the Gregorian calendar.

Simple XML Array Helper

2011-03-18T06:47:00.001-07:00

Simple XML Array Helper

Short description:

Generate or convert XML documents into arrays

Groups:

XML

PHP 5

Supplied by:

Kirill Shvakov

Detailed description:

This class can generate or convert XML documents into arrays.

It can parse a XML document and return a nested array that represents its structure of tags and data.

The class can also do the opposite, i.e. generate XML documents from nested arrays with the XML document structure.

SmartGAPI

2011-03-18T06:31:00.000-07:00

SmartGAPI

Short description:

Display site statistics from Google Analytics

Groups:

PHP 5

Statistics

AJAX

Supplied by:

Michele Andreoli

Detailed description:

This class can display site statistics from Google Analytics.

It uses the Google Analytics client class by Stig Manning to retrieve site statistics by sending HTTP requests to the Google Analytics API Web server.

The main class can generate HTML and JavaScript that users jQuery to send AJAX requests that retrieves and displays the site statistics.

Cache DBA

2011-03-16T17:45:00.001-07:00

Cache DBA

Short description:

Store cache data from flat file databases

Groups:

PHP 5

Databases

Cache

Supplied by:

Gjero Krsteski

Detailed description:

This class can store and retrieve cache data from flat file databases.

It takes a given object and stores its serialized information as a string of data in flat file database using the DBA extension.

The class can also retrieve and unserialize the previously stored object from the cache database file if the cache file exists and it did not expire.

It can also delete existing cache entries explicitly. A separate class exists to automatically delete all expired cache database entries.

Gammu SMS Inject - PHP Classes

2011-03-16T17:42:00.000-07:00

Short description:

Send SMS messages using Gammu MySQL storage

Groups:

PHP 5

Databases

Wireless and Mobile

Supplied by:

ikhsan

Detailed description:

This class can send SMS messages using Gammu MySQL storage.

It can send messages to one or more recipients using the Gammu MySQL database.

The class creates records for the new messages in MySQL database with the outbox of Gammu.

It can send also long messages by splitting them in multiple parts.

Gammu SMS Inject

PDO: Connect to ODBC

2010-06-27T23:35:00.001-07:00

There are many connections ODBC can create, here we show how to connect to a MS Access database named accounts. The specified path is c:\\accounts.mdb.
<%php


try {
    $dbh = new PDO("odbc:Driver={Microsoft Access Driver (*.mdb)};Dbq=C:\accounts.mdb;Uid=Admin");
    }
catch (PDOException $e)
    {
    echo $e->getMessage();
    }

%>

PDO: Connect to Oracle

2010-06-27T23:34:00.001-07:00

The Oracle database is used by many 'enterprise' companies but these days there are sleeker options. Lets see a simple connection to Oracle

<%php


try {
    $dbh = new PDO("OCI:", "username", "password")
    }
catch (PDOException $e)
    {
    echo $e->getMessage();
    }

%>

This works fine for a simple Oracle connection. The oracle driver may take two optional parameters, The database name, and the character set. To connect with a database name of "accounts" and a charset of UTF-8 the following code should be used.
<%php


try {
    $dbh = new PDO("OCI:dbname=accounts;charset=UTF-8", "username", "password");
    }
catch (PDOException $e)
    {     echo $e->getMessage();     }

%>

PDO: Connect to Informix

2010-06-27T23:33:00.001-07:00

Informix is popular with many windows users also, this example shows how to connect to an informix database cataloged as InformixDB in odbc.ini:
<%php


try {
    $dbh = new PDO("informix:DSN=InformixDB", "username", "password");
    }
catch (PDOException $e)
    {
    echo $e->getMessage();
    }

%>

PDO: Connect to Firebird

2010-06-27T23:32:00.000-07:00

Often used by developers using windows, Firebird is a good database and connection is just as simple as the examples above.

 <%phptry {
    $dbh = new PDO("firebird:dbname=localhost:C:\Programs\Firebird\DATABASE.FDB", "SYSDBA", "masterkey");
    }  
catch (PDOException $e)
    {
    echo $e->getMessage();
    }%>

PDO: Connect to MySQL

2010-06-27T23:19:00.000-07:00

MySQL is the choice of many web developers and will be used as the database of choice for much of this tutorial. Here we see how to connect to a MySQL database.

 
<7php
/*** mysql hostname ***/$hostname = 'localhost';
/*** mysql username ***/$username = 'username';
/*** mysql password ***/$password = 'password';

try {
    $dbh = new PDO("mysql:host=$hostname;dbname=mysql", $username, $password);
    /*** echo a message saying we have connected ***/
    echo 'Connected to database';
    }
catch(PDOException $e)
    {
    echo $e->getMessage();
    }7>

PDO: Connect to SQLite

2010-06-27T23:18:00.000-07:00

When PDO is used with SQLite, database creation becomes even easier. Simply specify the path to the database file and it will be loaded. If the database file does not exist, PDO will attempt to create it. Lets see how we go with the same code but change the database to SQLite.

 <7phptry {
    /*** connect to SQLite database ***/
    $dbh = new PDO("sqlite:/path/to/database.sdb");
    }
catch(PDOException $e)
    {
    echo $e->getMessage();
    }7>

Because the database path does not exist and cannot be created, an exception is thrown, the exception is caught in the catch block and the error message is displayed with $e->Message(). Now that we know how to create a database, we can create tables and INSERT some data.
Another feature of SQLite is the ability to create tables in memory. This can be amazingly helpful if you wish to create tempory databases or tables or even for development code.

 <7phptry {
    /*** connect to SQLite database ***/
    $db = new PDO("sqlite::memory");

    /*** a little message to say we did it ***/
    echo 'database created in memory';
    }
catch(PDOException $e)
    {
    echo $e->getMessage();
    }7>

We see above that a database is created in memory and a message is displayed to let us know. If the creation of the database failed, a PDO exception would be thrown and the script terminated at that point, passing control to the catch block.

PDO: Connect with PgSQL

2010-06-27T23:15:00.000-07:00

As mentioned above, you may have previously tried to connect to a PgSQL database using pg_connect. Here we connect with PDO.

<7php

 try {
    $db = new PDO("pgsql:dbname=pdo;host=localhost", "username", "password" );
    echo "PDO connection object created";
    }
catch(PDOException $e)
    {
    echo $e->getMessage();
    }

7>

So that was a bit of a no-brainer to start with, we see the use of "new" to create the PDO object followed by the database type username and password. This should be familiar to most people who have connected to a database before using traditional methods.. As we have used try{} and catch(){} we see upon failure that an exception is thrown with the error message "could not find driver". This tells us the PDO_PGSQL driver is not present and needs to be loaded. As noted, an exception is thrown. PDO can handle errors in several ways, more on this later.
How did it connect to the database?
The database connection is handled internally by PDO's __construct() and this represents our database connection.
Lets see what happens if we try to connect to database as we did above without catching the exception and see what happens..

 <7php
 $db = new PDO("pgsql:dbname=no_database;host=localhost", "username", "password" );

7>

From the above snippet you will get a result something like this below

Fatal error: Uncaught exception 'PDOException' with message 'could not find driver' in /www/pdo.php:2 Stack trace: #0 /www/pdo.php(2): PDO->__construct('pgsql:dbname=pd...', 'username', 'password') #1 {main} thrown in /www/pdo.php on line 2

This is the default behaviour when an exception is not caught, a backtrace is generated and the script is terminated. As you can see, all the information is dumped including the file path and the database username and password. It is the responsibility of the coder to catch exceptions or to deal with the errors using set_exception_handler() function to prevent this happening. More about handling errors and exceptions later.

What is PDO

2010-06-27T23:12:00.000-07:00

PDO is a PHP extension to formalise PHP's database connections by creating a uniform interface. This allows developers to create code which is portable across many databases and platforms. PDO is _not_ just another abstraction layer like PearDB although PearDB may use PDO as a backend. Those of you familiar with Perls DBI may find the syntax disturbingly familiar.

What databases does PDO support?

PDO supports many of the popular databases as seen on the list below.

DBLIB: FreeTDS / Microsoft SQL Server / Sybase
Firebird (http://firebird.sourceforge.net/): Firebird/Interbase 6
IBM (IBM DB2)
INFORMIX - IBM Informix Dynamic Server
MYSQL (http://www.mysql.com/): MySQL 3.x/4.0
OCI (http://www.oracle.com): Oracle Call Interface
ODBC: ODBC v3 (IBM DB2 and unixODBC)
PGSQL (http://www.postgresql.org/): PostgreSQL
SQLITE (http://sqlite.org/): SQLite 3.x

To see if the PDO driver is available for your database, check phpinfo() and you should have a section named PDO and another pdo_mysql or pdo_sqlite depending on your choice of database. You may also check the available drivers with the static method PDO::getAvailableDrivers().

 
foreach(PDO::getAvailableDrivers() as $driver)
    {
    echo $driver.'';
    }?>

To enable PDO simply configure --enable-pdo and --with-pdo_sqlite --with_pdo_mysql or whatever database needs supporting by PDO.
Windows users will need to un-comment the appropriate line in php.ini and restart the web server.

Scalar Datatypes

2010-05-20T21:26:00.000-07:00

Scalar datatypes are capable of containing a single item of information. Several datatypes fall

under this category, including Boolean, integer, float, and string.

Boolean

The Boolean datatype is named after George Boole (1815–1864), a mathematician who is

considered to be one of the founding fathers of information theory. A Boolean variable repre-

sents truth, supporting only two values: TRUE or FALSE (case insensitive). Alternatively, you can

use zero to represent FALSE, and any nonzero value to represent TRUE. A few examples follow:

$alive = false; # $alive is false.

$alive = 1; # $alive is true.

$alive = -1; # $alive is true.

$alive = 5; # $alive is true.

$alive = 0; # $alive is false.

Integer

An integer is quite simply a whole number, or one that does not contain fractional parts. Decimal

(base 10), octal (base 8), and hexadecimal (base 16) numbers all fall under this category. Several

examples follow:

42 # decimal

-678900 # decimal

0755 # octal

0xC4E # hexadecimal

The maximum supported integer size is platform-dependent, although this is typically

positive or negative 231. If you attempt to surpass this limit within a PHP script, the number will

be automatically converted to a float. An example follows:

<?php

$val = 45678945939390393678976;

echo $val + 5;

?>

This is the result:

4.567894593939E+022

Float

Floating-point numbers, also referred to as floats, doubles, or real numbers, allow you to

specify numbers that contain fractional parts. Floats are used to represent monetary values,

weights, distances, and a whole host of other representations in which a simple integer value

won’t suffice. PHP’s floats can be specified in a variety of ways, each of which is exemplified

here:

4.5678

4.0

8.7e4

1.23E+11

String

Simply put, a string is a sequence of characters treated as a contiguous group. Such groups are

typically delimited by single or double quotes, although PHP also supports another delimitation

methodology, which is introduced in the later section “String Interpolation.” The ramifications

of all three delimitation methods are also discussed in that section.

The following are all examples of valid strings:

"whoop-de-do"

'subway\n'

"123$%^789"

Historically, PHP treated strings in the same fashion as arrays (see the next section,

“Compound Datatypes,” for more information about arrays), allowing for specific characters

to be accessed via array offset notation. For example, consider the following string:

$color = "maroon";

You could retrieve and display a particular character of the string by treating the string as

an array, like this:

echo $color[2]; // outputs 'r'

Although this is convenient, it can lead to some confusion, and thus PHP 5 introduces

specialized string offset functionality, which Chapter 9 covers in some detail. Additionally,

Chapter 9 is devoted to a thorough presentation of many of PHP’s valuable string and regular

expression functions.

Output

2010-05-20T19:25:00.000-07:00

Most Web applications involve a high degree of interactivity. Well-written scripts are constantly

communicating with users, via both tool interfaces and request responses. PHP offers a number of

means for displaying information, each of which is discussed in this section.

print()

boolean print (argument)

The print() statement is responsible for providing user feedback, and it is capable of displaying

both raw strings and variables. All of the following are plausible print() statements:

<?php

print("I love the summertime.");

?>

<?php

$season = "summertime";

print "I love the $season.";

?>

<?php

print "I love the

summertime.";

?>

<?php

$season = "summertime";

print "I love the ".$season."";

?>

All these statements produce identical output:

I love the summertime.

While the first three variations are likely quite easy to understand, the last one might not

be so straightforward. In this last variation, three strings were concatenated together using a

period, which when used in this context is known as the concatenation operator. This practice

is commonly employed when concatenating variables, constants, and static strings together.

You’ll see this strategy used repeatedly throughout the entire book.

■Note Although the official syntax calls for the use of parentheses to enclose the argument, you have the

option of omitting them. Many programmers tend to choose this option, simply because the target argument

is equally apparent without them.

echo()

void echo (string argument1 [, ...string argumentN])

The echo() statement operates similarly to print(), except for two differences. First, it cannot

be used as part of a complex expression because it returns void, whereas print() returns a

Boolean. Second, echo() is capable of outputting multiple strings. The utility of this particular

trait is questionable; using it seems to be a matter of preference more than anything else.

Nonetheless, it’s available should you feel the need. Here’s an example:

<?php

$heavyweight = "Lennox Lewis";

$lightweight = "Floyd Mayweather";

echo $heavyweight, " and ", $lightweight, " are great fighters.";

?>

This code produces the following:

Lennox Lewis and Floyd Mayweather are great fighters.

■Tip Which is faster, echo() or print()? The fact that they are functionally interchangeable leaves many

pondering this question. The answer is that the echo() function is a tad faster, because it returns nothing,

whereas print() returns a Boolean value informing the caller whether or not the statement was successfully

output. It’s rather unlikely that you’ll notice any speed difference, however, so you can consider the usage

decision to be one of stylistic concern.

printf()

boolean printf (string format [, mixed args])

The printf() function is functionally identical to print(), outputting the arguments specified

in args, except that the output is formatted according to format. The format parameter allows

you to wield considerable control over the output data, be it in terms of alignment, precision,

type, or position. The argument consists of up to five components, which should appear in

format in the following order:

• Padding specifier: This optional component determines which character will be used to

pad the outcome to the correct string size. The default is a space character. An alternative

character is specified by preceding it with a single quotation.

• Alignment specifier: This optional component determines whether the outcome should

be left- or right-justified. The default is right-justified; you can set the alignment to left

with a negative sign.

• Width specifier: This optional component determines the minimum number of characters

that should be output by the function.

• Precision specifier: This optional component determines the number of decimal digits

that should be displayed. This component affects only data of type float.

• Type specifier: This component determines how the argument will be cast. The supported

type specifiers are listed in Table .

Type	Description
%b	Argument considered an integer; presented as a binary number
%c	Argument considered an integer; presented as a character corresponding to that ASCII value
%d	Argument considered an integer; presented as a signed decimal number
%f	Argument considered a floating-point number; presented as a floating-point number
%o	Argument considered an integer; presented as an octal number
%s	Argument considered a string; presented as a string
%u	Argument considered an integer; presented as an unsigned decimal number
%x	Argument considered an integer; presented as a lowercase hexadecimal number
%X	Argument considered an integer; presented as an uppercase hexadecimal number

Consider a few examples:

printf("$%01.2f", 43.2); // $43.20

printf("%d beer %s", 100, "bottles"); // 100 beer bottles

printf("%15s", "Some text"); // Some text

Sometimes it’s convenient to change the output order of the arguments, or repeat the

output of a particular argument, without explicitly repeating it in the argument list. This is

done by making reference to the argument in accordance with its position. For example, %2$

indicates the argument located in the second position of the argument list, while %3$ indicates

the third. However, when placed within the format string, the dollar sign must be escaped, like

this: %2\$. Two examples follow:

printf("The %2\$s likes to %1\$s", "bark", "dog");

// The dog likes to bark

printf("The %1\$s says: %2\$s, %2\$s.", "dog", "bark");

// The dog says: bark, bark.

sprintf()

string sprintf (string format [, mixed arguments])

The sprintf() function is functionally identical to printf(), except that the output is assigned

to a string rather than output directly to standard output. An example follows:

$cost = sprintf("$%01.2f", 43.2); // $cost = $43.20

Comments

2010-05-20T18:44:00.000-07:00

Whether for your own benefit or for that of a programmer later tasked with maintaining your

code, the importance of thoroughly commenting your code cannot be overstated. PHP offers

several syntactical variations, each of which is introduced in this section.

Single-line C++ Syntax

Comments often require no more than a single line. Because of its brevity, there is no need to

delimit the comment’s conclusion, because the newline (\n) character fills this need quite

nicely. PHP supports C++ single-line comment syntax, which is prefaced with a double-slash (//),

like this:

<?php

// Title: My PHP program

// Author: Jason

print "This is a PHP program";

?>
Shell Syntax

PHP also supports an alternative to the C++-style single-line syntax, known as shell syntax,

which is prefaced with a hash mark (#). Revisiting the previous example:

<?php

# Title: My PHP program

# Author: Jason

print "This is a PHP program";

?>

Multiple-line C Syntax

It’s often convenient to include somewhat more verbose functional descriptions or other

explanatory notes within code, which logically warrant numerous lines. Although you could preface each line with C++ or shell-style delimiters, PHP also offers a multiple-line variant that

both opens and closes the comment. Consider the following multiline comment:

<?php

/*

Title: My PHP Program

Author: Jason

Date: October 10, 2005

*/

?>

Multiline commentary syntax is particularly useful when generating documentation from

code, because it offers a definitive means for distinguishing between disparate comments, a

convenience not easily possible using single-line syntax.

Embedding Multiple Code Blocks

2010-05-20T18:29:00.000-07:00

You can escape to and from PHP as many times as required throughout a given page. For
instance, the following example is perfectly acceptable:
//html>
// head>
// ttitle>
//
// bbody>
// // $date = "May 18, 2003";
// ?>
//

Today's date is

//
//
Note that any variables declared in a prior code block are “remembered” for later blocks,
as was the case with the $date variable in this example.

Mail

2010-05-20T18:28:00.000-07:00

PHP’s mail() function offers a convenient means for sending e-mail messages via PHP scripts
Four directives are available for determining PHP’s behavior in this respect.
SMTP (string)
Scope: PHP_INI_ALL; Default value: localhost
The SMTP directive, applicable only for Win32 operating systems, determines the DNS name
or IP address of the SMTP server that PHP should use when sending mail. Linux/Unix users
should look to the sendmail_path directive in order to configure PHP’s mail feature.
smtp_port (int)
Scope: PHP_INI_ALL; Default value: 25
The smtp_port directive, applicable only for Win32 operating systems, specifies the port that
PHP should use when sending mail via the server designated by the SMTP directive.
sendmail_from (string)
Scope: PHP_INI_ALL; Default value: Null
The sendmail_from directive, applicable only for Win32 operating systems, designates the
sender identity when PHP is used to initiate the delivery of e-mail.
sendmail_path (string)
Scope: PHP_INI_SYSTEM; Default value: DEFAULT_SENDMAIL_PATH
The sendmail_path directive, applicable only for Unix operating systems, is primarily used to
pass additional options to the sendmail daemon, although it could also be used to determine
the location of sendmail when installed in a nonstandard directory.

Dynamic Extensions

2010-05-20T18:27:00.000-07:00

The Dynamic Extensions section contains a single directive, extension.
extension (string)
Scope: PHP_INI_ALL; Default value: Null
The extension directive is used to dynamically load a particular module. On the Win32 operating
system, a module might be loaded like this:
extension = php_java.dll
On Unix, it would be loaded like this:
extension = php_java.so
Keep in mind that on either operating system, simply uncommenting or adding this line
doesn’t necessarily enable the relevant extension. You’ll also need to ensure that the appro-
priate software is installed on the operating system. For example, to enable Java support, you
also need to install the JDK.

File Uploads

2010-05-18T06:42:00.000-07:00

PHP supports the uploading and subsequent administrative processing of both text and binary
files via the POST method. Three directives are available for maintaining this functionality,
each of which is introduced in this section.
file_uploads (On, Off)
Scope: PHP_INI_SYSTEM; Default value: On
The file_uploads directive determines whether PHP’s file uploading feature is enabled.
upload_tmp_dir (string)
Scope: PHP_INI_SYSTEM; Default value: Null
When files are first uploaded to the server, most operating systems place them in a staging, or
temporary, directory. You can specify this directory for files uploaded via PHP by using the
upload_tmp_dir directive.
upload_max_filesize (integer)M
Scope: PHP_INI_SYSTEM; Default value: 2M
The upload_max_filesize directive sets an upper limit, in megabytes, on the size of a file
processed using PHP’s upload mechanism.
fopen Wrappers
This section contains five directives pertinent to the access and manipulation of remote files.
allow_url_fopen (On, Off)
Scope: PHP_INI_ALL; Default value: On
Enabling allow_url_fopen allows PHP to treat remote files almost as if they were local. When
enabled, a PHP script can access and modify files residing on remote servers, if the files have
the correct permissions.
from (string)
Scope: PHP_INI_ALL; Default value: Null
The from directive is perhaps misleading in its title in that it actually determines the password,
rather than the identity, of the anonymous user used to perform FTP connections. Therefore,
if from is set like this:
from = "jason@example.com"
the username anonymous and password jason@example.com will be passed to the server when
authentication is requested.
user_agent (string)
Scope: PHP_INI_ALL; Default value: Null
PHP always sends a content header along with its processed output, including a user agent
attribute. This directive determines the value of that attribute.
default_socket_timeout (integer)
Scope: PHP_INI_ALL; Default value: 60
This directive determines the timeout value of a socket-based stream, in seconds.
auto_detect_line_endings (On, Off)
Scope: PHP_INI_ALL; Default value: Off
One never-ending source of developer frustration is derived from the end-of-line (EOL)
character, because of the varying syntax employed by different operating systems. Enabling
auto_detect_line_endings determines whether the data read by fgets() and file() uses
Macintosh, MS-DOS, or Unix file conventions.

Configuration Directive Scope

2010-05-18T06:13:00.000-07:00

Can configuration directives be modified anywhere? Good question. The answer is no, for a
variety of reasons, mostly security related. Each directive is assigned a scope, and the directive
can be modified only within that scope. In total, there are four scopes:
• PHP_INI_PERDIR: Directive can be modified within the php.ini, httpd.conf, or .htaccess
files
• PHP_INI_SYSTEM: Directive can be modified within the php.ini and httpd.conf files
• PHP_INI_USER: Directive can be modified within user scripts
• PHP_INI_ALL: Directive can be modified anywhere

The Apache httpd.conf and .htaccess Files

2010-05-18T05:58:00.001-07:00

When PHP is running as an Apache module, you can modify many of the directives through
either the httpd.conf file or the .htaccess file. This is accomplished by prefixing the name =
value pair with one of the following keywords:
• php_value: Sets the value of the specified directive.
• php_flag: Sets the value of the specified Boolean directive.
• php_admin_value: Sets the value of the specified directive. This differs from php_value in
that it cannot be used within an .htaccess file and cannot be overridden within virtual
hosts or .htaccess.
• php_admin_flag: Sets the value of the specified directive. This differs from php_value in
that it cannot be used within an .htaccess file and cannot be overridden within virtual
hosts or .htaccess.

Installing Apache and PHP on Windows

2010-05-18T05:41:00.000-07:00

Whereas previous Windows-based versions of Apache weren’t optimized for the Windows
platform, the Win32 version of Apache 2 was completely rewritten to take advantage of Windows
platform-specific features. Even if you don’t plan to deploy your application on Windows, it
nonetheless makes for a great localized testing environment for those users who prefer it over
other platforms. The installation process follows:
1. Start the Apache installer by double-clicking the apache_X.X.XX-win32-x86-no_ssl.msi
icon.
2. The installation process begins with a welcome screen. Take a moment to read the
screen and then click Next.
3. The License Agreement is displayed next. Carefully read through the license. Assuming
that you agree with the license stipulations, click Next.
4. A screen containing various items pertinent to the Apache server is displayed next. Take
a moment to read through this information and then click Next.
5. You will be prompted for various items pertinent to the server’s operation, including the
Network Domain, Server Name, and Administrator’s Email Address. If you know this
information, fill it in now; otherwise, just use localhost for the first two items, and put
in any e-mail address for the last. You can always change this information later in the
httpd.conf file. You’ll also be prompted as to whether Apache should run as a service
for all users or only for the current user. If you want Apache to automatically start with
the operating system, which is recommended, then choose to install Apache as a service for
all users. When you’re finished, click Next.
6. You are prompted for a Setup Type: Typical or Custom. Unless there is a specific reason
you don’t want the Apache documentation installed, choose Typical and click Next.
Otherwise, choose Custom, click Next, and, on the next screen, uncheck the Apache
Documentation option.
7. You’re prompted for the Destination folder. By default, this is C:\Program Files\Apache
Group. Consider changing this to C:\, which will create an installation directory
C:\Apache2\. Regardless of what you choose, keep in mind that the latter is used here
for the sake of convention. Click Next.
8. Click Install to complete the installation. That’s it for Apache. Next you’ll install
9. Unzip the PHP package, placing the contents into C:\php5\. You’re free to choose
any installation directory you please, but avoid choosing a path that contains spaces.
Regardless, the installation directory C:\php5\ will be used throughout this chapter for
consistency.
10. Make the php5ts.dll file available to Apache. This is most easily accomplished simply
by adding the PHP installation directory path to the Windows Path. To do so, navigate to
Start ➤ Settings ➤ Control Panel ➤ System, choose the Advanced tab, and click the
Environment Variables button. In the Environment Variables dialog box, scroll through
the System variables pane until you find Path. Double-click this line and, in the Edit
System Variable dialog box, append C:\php5 to the path, as is depicted in Figure 2-1.

11. Navigate to C:\apache2\conf and open httpd.conf for editing.
12. Add the following three lines to the httpd.conf file. Consider adding them directly
below the block of LoadModule entries located in the bottom of the Global Environment
section.
LoadModule php5_module c:/php5/php5apache2.dll
AddType application/x-httpd-php .php
PHPIniDir "C:\php5"
13. Rename the php.ini-dist file php.ini and save it to the C:\php5 directory. The php.ini
file contains hundreds of directives that are responsible for tweaking PHP’s behavior. The
later section “Configuration” examines php.ini’s purpose and contents in detail. Note
that you can place this configuration file anywhere you please, but if you choose a nondefault
location, then you also need to configure PHP using the --with-config-file-path
option. Also note that there is another default configuration file at your disposal,
php.ini-recommended. This file sets various nonstandard settings, and is intended to
better secure and optimize your installation, although this configuration may not be
fully compatible with some of the legacy applications. Consider using this file in lieu
of php.ini-dist.
14. If you’re using Windows NT, 2000, or XP, navigate to Start ➤ Settings ➤ Control Panel ➤
Administrative Tools ➤ Services.
15. Locate Apache in the list, and make sure that it is started. If it is not started, highlight the
label and click Start the service, located to the left of the label. If it is started, highlight
the label and click Restart the service, so that the changes made to the httpd.conf file
take effect. Next, right-click Apache and choose Properties. Ensure that the startup type
is set to Automatic. If you’re still using Windows 95/98, you need to start Apache manually
via the shortcut provided on the Start menu.

General Language Features - Power

2010-05-18T05:28:00.000-07:00

The earlier introduction to PHP 5 alluded to the fact that the new version is more qualitative
than quantitative in comparison to previous versions. Previous major versions were accompanied
by enormous additions to PHP’s default libraries, to the tune of several hundred new
functions per release. Presently, 113 libraries are available, collectively containing well over
1,000 functions. Although you’re likely aware of PHP’s ability to interface with databases,
manipulate form information, and create pages dynamically, you might not know that PHP
can also do the following:
• Create and manipulate Macromedia Flash, image, and Portable Document Format
(PDF) files
• Evaluate a password for guessability by comparing it to language dictionaries and easily
broken patterns
• Communicate with the Lightweight Directory Access Protocol (LDAP)
• Parse even the most complex of strings using both the POSIX and Perl-based regular
expression libraries
• Authenticate users against login credentials stored in flat files, databases, and even
Microsoft’s Active Directory
• Communicate with a wide variety of protocols, including IMAP, POP3, NNTP, and DNS,
among others
• Communicate with a wide array of credit-card processing solutions
Of course, the coming chapters cover as many of these and other interesting and useful
features of PHP as possible.

Paths and Directories

2009-06-18T06:40:00.000-07:00

This section introduces directives that determine PHP’s default path settings. These paths are
used for including libraries and extensions, as well as for determining user Web directories and
Web document roots.
include_path (string)
Scope: PHP_INI_ALL; Default value: PHP_INCLUDE_PATH
The path to which this parameter is set serves as the base path used by functions such as
include(), require(), and fopen_with_path(). You can specify multiple directories by separating
each with a semicolon, as shown in the following example:
include_path=".:/usr/local/include/php;/home/php"
By default, this parameter is set to the path defined by the environment variable
PHP_INCLUDE_PATH.
Note that on Windows, backward slashes are used in lieu of forward slashes, and the drive
letter prefaces the path. For example:
include_path=".;C:\php5\includes"
doc_root (string)
Scope: PHP_INI_SYSTEM; Default value: Null
This parameter determines the default from which all PHP scripts will be served. This parameter
is used only if it is not empty.
user_dir (string)
Scope: PHP_INI_SYSTEM; Default value: Null
The user_dir directive specifies the absolute directory PHP uses when opening files using the
/~username convention. For example, when user_dir is set to /home/users and a user attempts
to open the file ~/gilmore/collections/books.txt, PHP knows that the absolute path is /home/
users/gilmore/collections/books.txt.
extension_dir (string)
Scope: PHP_INI_SYSTEM; Default value: PHP_EXTENSION_DIR
The extension_dir directive tells PHP where its loadable extensions (modules) are located. By
default, this is set to ./, which means that the loadable extensions are located in the same
directory as the executing script. In the Windows environment, if extension_dir is not set, it
will default to C:\PHP-INSTALLATION-DIRECTORY\ext\. In the Unix environment, the exact location
of this directory depends on several factors, although it’s quite likely that the location will
be PHP-INSTALLATION-DIRECTORY/lib/php/extensions/no-debug-zts-RELEASE-BUILD-DATE/.
enable_dl (On, Off)
Scope: PHP_INI_SYSTEM; Default value: On
The enable_dl() function allows a user to load a PHP extension at run time; that is, during a
script’s execution.

Dynamic Extensions

2009-05-28T06:47:00.000-07:00

The Dynamic Extensions section contains a single directive, extension.
extension (string)
Scope: PHP_INI_ALL; Default value: Null
The extension directive is used to dynamically load a particular module. On the Win32 operating
system, a module might be loaded like this:
extension = php_java.dll
On Unix, it would be loaded like this:
extension = php_java.so
Keep in mind that on either operating system, simply uncommenting or adding this line
doesn’t necessarily enable the relevant extension. You’ll also need to ensure that the appropriate
software is installed on the operating system. For example, to enable Java support, you
also need to install the JDK.

Safe Mode

2009-05-20T06:27:00.000-07:00

When you deploy PHP in a multiuser environment, such as that found on an ISP’s shared
server, you might want to limit its functionality. As you might imagine, offering all users full
reign over all PHP’s functions could open up the possibility for exploiting or damaging server
resources and files. As a safeguard for using PHP on shared servers, PHP can be run in a restricted,
or safe, mode.
Enabling safe mode has a great many implications, including the automatic disabling of
quite a few functions and various features deemed to be potentially insecure and thus possibly
damaging if they are misused within a local script. A small sampling of these disabled functions
and features includes parse_ini_file(), chmod(), chown(), chgrp(), exec(), system(), and
backtick operators. Enabling safe mode also ensures that the owner of the executing script
matches the owner of any file or directory targeted by that script.
In addition, enabling safe mode opens up the possibility for activating a number of other
restrictions via other PHP configuration directives, each of which is introduced in this section.
safe_mode (On, Off)
Scope: PHP_INI_SYSTEM; Default value: Off
Enabling the safe mode directive results in PHP being run under the aforementioned
constraints.
safe_mode_gid (On, Off)
Scope: PHP_INI_SYSTEM; Default value: Off
When safe mode is enabled, an enabled safe_mode_gid enforces a GID (group ID) check when
opening files. When safe_mode_gid is disabled, a more restrictive UID (user ID) check is enforced.
safe_mode_include_dir (string)
Scope: PHP_INI_SYSTEM; Default value: Null
The safe_mode_include_dir provides a safe haven from the UID/GID checks enforced when
safe_mode and potentially safe_mode_gid are enabled. UID/GID checks are ignored when files
are opened from the assigned directory.
safe_mode_exec_dir (string)
Scope: PHP_INI_SYSTEM; Default value: Null
When safe mode is enabled, the safe_mode_exec_dir parameter restricts execution of executables
via the exec() function to the assigned directory. For examples, if you want to restrict
execution to functions found in /usr/local/bin, you use this directive:
safe_mode_exec_dir = "/usr/local/bin"
safe_mode_allowed_env_vars (string)
Scope: PHP_INI_SYSTEM; Default value: PHP_
When safe mode is enabled, you can restrict which operating system–level environment variables
users can modify through PHP scripts with the safe_mode_allowed_env_vars directive.
For example, setting this directive as follows limits modification to only those variables with a
PHP_ or MYSQL_ prefix:
safe_mode_allowed_env_vars = "PHP_,MYSQL_"
Keep in mind that leaving this directive blank means that the user can modify any environment
variable.
safe_mode_protected_env_vars (string)
Scope: PHP_INI_SYSTEM; Default value: LD_LIBRARY_PATH
The safe_mode_protected_env_vars directive offers a means for explicitly preventing certain
environment variables from being modified. For example, if you want to prevent the user from
modifying the PATH and LD_LIBRARY_PATH variables, you use this directive:
safe_mode_protected_env_vars = "PATH, LD_LIBRARY_PATH"
open_basedir (string)
Scope: PHP_INI_SYSTEM; Default value: Null
Much like Apache’s DocumentRoot, PHP’s open_basedir directive can establish a base directory
to which all file operations will be restricted. This prevents users from entering otherwise
restricted areas of the server. For example, suppose all Web material is located within the directory
/home/www. To prevent users from viewing and potentially manipulating files like /etc/
passwd via a few simple PHP commands, consider setting open_basedir like this:
open_basedir = "/home/www/"
Note that the influence exercised by this directive is not dependent upon the safe_mode
directive.
disable_functions (string)
Scope: PHP_INI_SYSTEM; Default value: Null
In certain environments, you may want to completely disallow the use of certain default
functions, such as exec() and system(). Such functions can be disabled by assigning them to
the disable_functions parameter, like this:
disable_functions = "exec, system";
Note that the influence exercised by this directive is not dependent upon the safe_mode
directive.
disable_classes (string)
Scope: PHP_INI_SYSTEM; Default value: Null
Given the new functionality offered by PHP’s embrace of the object-oriented paradigm, it
likely won’t be too long before you’re using large sets of class libraries. There may be certain
classes found within these libraries that you’d rather not make available, however. You can
prevent the use of these classes via the disable_classes directive. For example, if you want to
disable two particular classes, named administrator and janitor, you use the following:
disable_classes = "administrator, janitor"
Note that the influence exercised by this directive is not dependent upon the safe_mode
directive.
ignore_user_abort (Off, On)
Scope: PHP_INI_ALL; Default value: On
How many times have you browsed to a particular page, only to exit or close the browser before
the page completely loads? Often such behavior is harmless. However, what if the server was in
the midst of updating important user profile information, or completing a commercial transaction?
Enabling ignore_user_abort causes the server to ignore session termination caused by
a user- or browser-initiated interruption.

Java classes

2009-05-19T06:50:00.000-07:00

PHP can instantiate Java classes via its Java extension. The following four directives determine
PHP’s behavior in this respect. Note that it’s also possible to run PHP as a Java servlet via the
Java Servlet API, although this topic isn’t discussed in this book. Check out the PHP manual for
more information.
java.class.path (string)
Scope: PHP_INI_ALL; Default value: Null
The java.class.path directory specifies the location where your Java classes are stored.
java.home (string)
Scope: PHP_INI_ALL; Default value: Null
The java.home directive specifies the location of the JDK binary directory.
java.library (string)
Scope: PHP_INI_ALL; Default value: JAVALIB
The java.library directive specifies the location of the Java Virtual Machine (JVM).
java.library.path (string)
Scope: PHP_INI_ALL; Default value: Null
The java.library.path directive specifies the location of PHP’s Java extension.

Language Options

2009-05-19T06:19:00.000-07:00

The directives located in this initial section determine some of the language’s most basic
behavior. You’ll definitely want to take a few moments to become acquainted with these
configuration possibilities.
engine (On, Off)
Scope: PHP_INI_ALL; Default value: On
This parameter is simply responsible for determining whether the PHP engine is available.
Turning it off prevents you from using PHP at all. Obviously, you should leave this enabled if
you plan to use PHP.
zend.ze1_compatibility_mode (On, Off)
Scope: PHP_INI_ALL; Default value: Off
Even at press time, some 18 months after PHP 5.0 released, PHP 4.X is still in widespread use. One
of the reasons for the protracted upgrade cycle is due to some incompatibilities between PHP 4
and 5. However, many developers aren’t aware that enabling the zend.ze1_compatibility_mode
directive allows PHP 4 applications to run without issue in version 5. Therefore, if you’d like to
use a PHP 4–specific application on a PHP 5–driven server, look to this directive.
short_open_tag (On, Off)
Scope: PHP_INI_ALL; Default value: On
PHP script components are enclosed within escape syntax. There are four different escape
formats, the shortest of which is known as short open tags, which looks like this:
echo "Some PHP statement";
?>
You may recognize that this syntax is shared with XML, which could cause issues in certain
environments. Thus, a means for disabling this particular format has been provided. When
short_open_tag is enabled (On), short tags are allowed; when disabled (Off), they are not.
asp_tags (On, Off)
Scope: PHP_INI_ALL; Default value: Off
PHP supports ASP-style script delimiters, which look like this:
<%
echo "Some PHP statement";
%>
If you’re coming from an ASP background and prefer to continue using this delimiter
syntax, you can do so by enabling this tag.
precision (integer)
Scope: PHP_INI_ALL; Default value: 12
PHP supports a wide variety of data types, including floating-point numbers. The precision
parameter specifies the number of significant digits displayed in a floating-point number
representation. Note that this value is set to 14 digits on Win32 systems and to 12 digits on
Unix.
y2k_compliance (On, Off)
Scope: PHP_INI_ALL; Default value: Off
Who can forget the Y2K scare of just a few years ago? Superhuman efforts were undertaken to
eliminate the problems posed by non–Y2K-compliant software, and although it’s very unlikely,
some users may be using wildly outdated, noncompliant browsers. If for some bizarre reason
you’re sure that a number of your site’s users fall into this group, then disable the y2k_compliance
parameter; otherwise, it should be enabled.
output_buffering ((On, Off) or (integer))
Scope: PHP_INI_SYSTEM; Default value: Off
Anybody with even minimal PHP experience is likely quite familiar with the following two
messages:
"Cannot add header information – headers already sent"
"Oops, php_set_cookie called after header has been sent"
These messages occur when a script attempts to modify a header after it has already been
sent back to the requesting user. Most commonly, they are the result of the programmer
attempting to send a cookie to the user after some output has already been sent back to the
browser, which is impossible to accomplish because the header (not seen by the user, but used
by the browser) will always precede that output. PHP version 4.0 offered a solution to this annoying
problem by introducing the concept of output buffering. When enabled, output buffering tells
PHP to send all output at once, after the script has been completed. This way, any subsequent
changes to the header can be made throughout the script, because it hasn’t yet been sent.
Enabling the output_buffering directive turns output buffering on. Alternatively, you can limit
the size of the output buffer (thereby implicitly enabling output buffering) by setting it to the
maximum number of bytes you’d like this buffer to contain.
If you do not plan to use output buffering, you should disable this directive, because it will
hinder performance slightly. Of course, the easiest solution to the header issue is simply to pass
the information before any other content whenever possible.

The php.ini File

2009-05-19T05:55:00.000-07:00

The PHP distribution comes with two configuration templates, php.ini-dist and
php.ini-recommended. The “Installation” section suggested that you use the latter, because
many of the parameters found within it have already been set to their suggested settings.
Taking this advice will likely save you a good deal of initial time and effort securing and
tweaking your installation, because there are almost 240 distinct configuration parameters in
this file. Although the default values go a long way toward helping you to quickly deploy PHP,
you’ll probably want to make additional adjustments to PHP’s behavior, so you’ll need to learn
a bit more about this file and its many configuration parameters. The upcoming section “PHP’s
Configuration Directives” presents a comprehensive introduction to many of these parameters,
explaining the purpose, scope, and range of each.
The php.ini file is PHP’s global configuration file, much like httpd.conf is to Apache, or
my.cnf (my.ini on Windows) is to MySQL. This file addresses 12 different aspects of PHP’s
behavior:
• Language Options
• Safe Mode
• Syntax Highlighting
• Miscellaneous
• Resource Limits
• Error Handling and Logging
• Data Handling
• Paths and Directories
• File Uploads
• Fopen Wrappers
• Dynamic Extensions
• Module Settings
Each of the listed items is introduced along with its respective parameters in the “PHP’s
Configuration Directives” section. Before you are introduced to them, however, take a moment
to review the php.ini file’s general syntactical characteristics. The php.ini file is a simple text
file, consisting solely of comments and parameter = key assignment pairs. Here’s a sample
snippet from the file:
;
; Safe Mode
;
safe_mode = Off
Lines beginning with a semicolon are comments; the parameter safe_mode is assigned the
value Off.
Exactly when changes take effect depends on how you installed PHP. If PHP is installed as
a CGI binary, the php.ini file is reread every time PHP is invoked, thus making changes instantaneous.
If PHP is installed as an Apache module, then php.ini is only read in once, when the
Apache daemon is first started. Therefore, if PHP is installed in the latter fashion, you must
restart Apache before any of the changes take effect.

Installing Apache and PHP on Linux/Unix

2009-05-19T05:35:00.000-07:00

This section guides you through the process of building Apache and PHP from source, targeting the
Unix platform. You need a respectable ANSI-C compiler and build system, two items that are
commonplace on the vast majority of distributions available today. In addition, PHP requires
the Flex (http://www.gnu.org/software/flex/flex.html) and Bison (http://www.gnu.org/
software/bison/bison.html) packages, while Apache requires at least Perl version 5.003. Again,
all three items are prevalent on most, if not all, modern Unix platforms. Finally, you need root
access to the target server to complete the build process.
Before beginning the installation process, for sake of convenience, consider moving both
packages to a common location, /usr/src/ for example. The installation process follows:
1. Unzip and untar Apache and PHP:
%>gunzip httpd-2_X_XX.tar.gz
%>tar xvf httpd-2_X_XX.tar
%>gunzip php-XX.tar.gz
%>tar xvf php-XX.tar
2. Configure and build Apache. At a minimum, you’ll want to pass two options. The first
option, --enable-so, tells Apache to enable the ability to load shared modules. The
second, --with-mpm=worker, tells Apache to use a threaded multiprocessing module
known as worker. Based on your particular needs, you might also consider using the
multiprocessing module prefork. See the Apache documentation for more information
regarding this important matter.
%>cd httpd-2_X_XX
%>./configure --enable-so --with-mpm=worker [other options]
%>make
3. Install Apache:
%>make install
4. Configure, build, and install PHP (see the section “Customizing the Unix Build” or
“Customizing the Windows Build,” depending on your operating system, for information
regarding modifying installation defaults and incorporating third-party
extensions into PHP):
%>cd ../php-X_XX
%>./configure --with-apxs2=/usr/local/apache2/bin/apxs [other options]
%>make
%>make install
5. Copy the php.ini-dist file to its default location and rename it php.ini. The php.ini file
contains hundreds of directives that are responsible for tweaking PHP’s behavior. The
later section “Configuration” examines php.ini’s purpose and contents in detail. Note
that you can place this configuration file anywhere you please, but if you choose a nondefault
location, then you also need to configure PHP using the --with-config-filepath
option. Also note that there is another default configuration file at your disposal,
php.ini-recommended. This file sets various nonstandard settings and is intended to
better secure and optimize your installation, although this configuration may not be
fully compatible with some of the legacy applications. Consider using this file in lieu of
php.ini-dist.
%>cp php.ini-recommended /usr/local/lib/php.ini
6. Open the httpd.conf file and verify that the following lines exist. (The httpd.conf file is
located at APACHE_INSTALL_DIR/conf/httpd.conf.) If they don’t exist, go ahead and add
them. Consider adding each alongside the other LoadModule and AddType entries,
respectively.
LoadModule php5_module modules/libphp5.so
AddType application/x-httpd-php .php
Believe it or not, that’s it! Restart the Apache server with the following command:
%>/usr/local/apache2/bin/apachectl restart

PHP’s mail

2009-05-18T06:49:00.000-07:00

PHP’s mail() function offers a convenient means for sending e-mail messages via PHP scripts.
Four directives are available for determining PHP’s behavior in this respect.
SMTP (string)
Scope: PHP_INI_ALL; Default value: localhost
The SMTP directive, applicable only for Win32 operating systems, determines the DNS name
or IP address of the SMTP server that PHP should use when sending mail. Linux/Unix users
should look to the sendmail_path directive in order to configure PHP’s mail feature.
smtp_port (int)
Scope: PHP_INI_ALL; Default value: 25
The smtp_port directive, applicable only for Win32 operating systems, specifies the port that
PHP should use when sending mail via the server designated by the SMTP directive.
sendmail_from (string)
Scope: PHP_INI_ALL; Default value: Null
The sendmail_from directive, applicable only for Win32 operating systems, designates the
sender identity when PHP is used to initiate the delivery of e-mail.
sendmail_path (string)
Scope: PHP_INI_SYSTEM; Default value: DEFAULT_SENDMAIL_PATH
The sendmail_path directive, applicable only for Unix operating systems, is primarily used to
pass additional options to the sendmail daemon, although it could also be used to determine
the location of sendmail when installed in a nonstandard directory.

General Language Features - Price

2009-05-18T05:32:00.000-07:00

Since its inception, PHP has been without usage, modification, and redistribution restrictions.
In recent years, software meeting such open licensing qualifications has been referred to as
open-source software. Open-source software and the Internet go together like bread and
butter. Open-source projects like Sendmail, Bind, Linux, and Apache all play enormous roles in
the ongoing operations of the Internet at large. Although the fact that open-source software is
freely available for use has been the characteristic most promoted by the media, several other
characteristics are equally important if not more so:
• Free of licensing restrictions imposed by most commercial products: Open-source
software users are freed of the vast majority of licensing restrictions one would expect of
commercial counterparts. Although some discrepancies do exist among license variants,
users are largely free to modify, redistribute, and integrate the software into other products.
• Open development and auditing process: Although there have been some incidents,
open-source software has long enjoyed a stellar security record. Such high standards are
a result of the open development and auditing process. Because the source code is freely
available for anyone to examine, security holes and potential problems are rapidly found
and fixed. This advantage was perhaps best summarized by open-source advocate
Eric S. Raymond, who wrote, “Given enough eyeballs, all bugs are shallow.”
• Participation is encouraged: Development teams are not limited to a particular organization.
Anyone who has the interest and the ability is free to join the project. The absence
of member restrictions greatly enhances the talent pool for a given project, ultimately
contributing to a higher-quality product.

General Language Features - Possibility

2009-05-18T05:31:00.000-07:00

PHP developers are rarely bound to any single implementation solution. On the contrary, a
user is typically fraught with choices offered by the language. For example, consider PHP’s
array of database support options. Native support is offered for over 25 database products,
including Adabas D, dBase, Empress, FilePro, FrontBase, Hyperwave, IBM DB2, Informix,
Ingres, Interbase, mSQL, direct MS-SQL, MySQL, Oracle, Ovrimos, PostgreSQL, Solid, Sybase,
Unix dbm, and Velocis. In addition, abstraction layer functions are available for accessing
Berkeley DB–style databases. Finally, two database abstraction layers are available, one called
the dbx module, and another via PEAR, titled the PEAR DB.
PHP’s powerful string-parsing capabilities is another feature indicative of the possibility
offered to users. In addition to more than 85 string-manipulation functions, both POSIX- and
Perl-based regular expression formats are supported. This flexibility offers users of differing
skill sets the opportunity not only to immediately begin performing complex string operations
but also to quickly port programs of similar functionality (such as Perl and Python) over to PHP.
Do you prefer a language that embraces functional programming? How about one that
embraces the object-oriented paradigm? PHP offers comprehensive support for both. Although
PHP was originally a solely functional language, the developers soon came to realize the
importance of offering the popular OOP paradigm, and took the steps to implement an
extensive solution.
The recurring theme here is that PHP allows you to quickly capitalize on your current skill
set with very little time investment. The examples set forth here are but a small sampling of this
strategy, which can be found repeatedly throughout the language.

General Language Features - Practicality

2009-05-18T05:24:00.000-07:00

From the very start, the PHP language was created with practicality in mind. After all, Lerdorf’s
original intention was not to design an entirely new language, but to resolve a problem that
had no readily available solution. Furthermore, much of PHP’s early evolution was not the
result of the explicit intention to improve the language itself, but rather to increase its utility to
the user. The result is a minimalist language, both in terms of what is required of the user and
in terms of the language’s syntactical requirements. For starters, a useful PHP script can consist of
as little as one line; unlike C, there is no need for the mandatory inclusion of libraries. For example,
the following represents a complete PHP script, the purpose of which is to output the current
date, in this case one formatted like September 23, 2005:

Another example of the language’s penchant for compactness is its ability to nest functions.
For example, you can effect numerous changes to a value on the same line by stacking functions
in a particular order, in the following case producing a pseudorandom string of five alphanumeric
characters, a3jh8 for instance:
$randomString = substr(md5(microtime()), 0, 5);
PHP is a loosely typed language, meaning there is no need to explicitly create, typecast, or
destroy a variable, although you are not prevented from doing so. PHP handles such matters
internally, creating variables on the fly as they are called in a script, and employing a best-guess
formula for automatically typecasting variables. For instance, PHP considers the following set
of statements to be perfectly valid:
$number = "5"; # $number is a string
$sum = 15 + $number; # Add an integer and string to produce integer
$sum = "twenty"; # Overwrite $sum with a string.
?>
PHP will also automatically destroy variables and return resources to the system when the
script completes. In these and in many other respects, by attempting to handle many of the
administrative aspects of programming internally, PHP allows the developer to concentrate
almost exclusively on the final goal, namely a working application.

ASP vs PHP: Speed

2009-05-01T20:54:00.000-07:00

Speed
Relatively, PHP is much faster and stable than ASP, this is because ASP is built on a COM-based architecture so whenever a program tries to connect to a database or calls for a COM object, there is an overhead on the server, and this COM overhead adds up and slows things down.
While in PHP, everything runs in PHP’s memory space , this implies that PHP code will run faster because there is no overhead of communicating with different COM objects in different processes.
In addition to this ASP is slower and is a more memory intensive application than PHP’s model because each ASP language compiler runs in its own process.

ASP vs PHP: Price and Versatility

2009-04-30T20:53:00.000-07:00

Price Compared to ASP, PHP installations are absolutely cheaper to install. PHP perfectly runs on Linux (which is a free OS) and programmers use MySQL .(which also comes FREE) ASP runs on the IIS Server (Internet Information Server) which requires Windows N.T/2000/2003 Servers or better. Aside from that ASP mostly uses MS-SQL Server as the back end which is really expensive. PHP obviously is cheaper than ASP.

Cross Platform compatibility
PHP programs run on a wide variety of Operating Systems Unix, Linux, Solaris and Window’s.ASP on the other hand only works flawlessly with Windows and not with other platforms. PHP offers more versatility than ASP.

Displaying Page Loading Time (Steps and Sample Code)

2009-04-29T20:49:00.001-07:00

Here is how to display your pageâ€™s loading time:

1. Use the function microtime() to get the time in micro-seconds
2. Use the explode() function to turn the micro-time into an array.
3. Combine the two parts to the array (the micro-seconds to the seconds).
4. Repeat steps 1,2 and 3 for the bottom of the page
5. Take the time taken at the end of the page from the time taken at the top of the page to determine the total loading time.
6. After rounding the microtime, return it to the browser.

At the top of your page, place:

$m_time = explode(" ",microtime());
$m_time = $m_time[0] + $m_time[1];
$starttime = $m_time;
?>

At the bottom of your page, place:

$round = 3;// The number of decimal places to round the micro time to.
$m_time = explode(" ",microtime());
$m_time = $m_time[0] + $m_time[1];
$endtime = $m_time;
$totaltime = ($endtime - $starttime);
echo "Page loading took:". round($totaltime,$round) ." seconds";
?>

Creating a Simple User Log (Sample Code)

2009-04-28T20:41:00.001-07:00

//use the date() function <----- comment
$time = date("F jS Y, h:iA");

//use PHP variable $remote_addr to get ip address
$ip = $REMOTE_ADDR;

//use PHP variable $http_referer to get referer
$referer = $HTTP_REFERER;

//user PHP variable $http_user_agent to get browser
$browser = $HTTP_USER_AGENT;

//what page they came from
$page = $_SERVER['REQUEST_URI'];

//use the fopen() function
$fp = fopen("log.html", "a");

//use the fputs() function
fputs($fp, "
Time: $time
IP: $ip
Referer: $referer
Browser: $browser
Page: $page
");

fclose($fp);

Note: Donâ€™t forget to create a blank log.html page, upload it to the server in the same directory as the page where the code will be placed, and CHMOD it to 777. Also, you can put this code anywhere on your main page.

Getting Your Php Certification

2009-04-27T20:11:00.001-07:00

Image Source:static.zend.com

Want to become a PHP programmer? PHP Certification is a type of exam in which you are required to pass a single test containing about 70 multiple choice questions. It was developed by the creator of PHP himself. If you pass this exam, you will be qualified to the next level which they call
Zend Certificate Engineer or ZCE. Currently, the medium for learning is PHP5. Gather study materials that are already based on PHP5.

What is all this for? You might ask. Basically, its sort of an online degree or certificate. The most important concept of this program is professional recognition. You can then use this to pursue your PHP programming career.

PHP and ASP Comparison

2009-04-26T20:55:00.000-07:00

What is PHP?
PHP or (PHP: Hypertext Preprocessor) is Open Source’s scripting language designed for the construction of dynamic web pages. PHP is largely used in server-side scripting, but can also be used from a command line interface or in standalone graphical applications.PHP commonly runs on a web server, taking the PHP code as its input and creating web pages as output. It can be set up on most web servers and on almost every operating system and platform for free.

What is ASP?
Active Server Pages (ASP) is Microsoft’s scripting language for building dynamic web sites, web applications and web services., First released in January 2002 , along with the version 1.0 of the .NET Framework, ASP.net is the successor to Microsoft’s Active Server Pages (ASP) technology. ASP.NET is made on the Common Language Runtime, allowing programmers to write ASP.NET code via any supported .NET language such as VBScript and Jscript.

Good Features of the evolt PHP Login system

2009-03-27T20:14:00.000-07:00

As an example of secure PHP programming, the evolt PHP login system has a list of good features as follows:

Safety â€“ Passwords are not saved in cookies

Levels â€“ Users are identified by different levels (admin, user etc.)

Admin Center â€“ As admin, you have full management of the users. View user profiles, delete and ban users, demote and upgrade user levels.

Tracking â€“ You can now tell how many visitors and registered users are viewing your site. Also it will show how many users your site has.

Account Info â€“ Registered users can edit and view their own information and also view otherâ€™s profile as well.

Error Form â€“ If an error occurs, they are redirected to an error form page that they can fill out to inform that there is an error page and error that occurred are displayed.

Password â€“ If users forget their password, they can have a new one generated and sent to their email.

A List of PHP Editors

2009-02-27T20:30:00.000-08:00

In case this may come in handy, here is a list of editors which can be used with the PHP scripting language.

Windows

ConTEXT - version 0.97.4; freeware
Crimson Editor - version 3.60; freeware
Programmer’s Notepad -
PSPad - version 4.3.0; freeware
Notepad++
NuSphere PhpED - version 5.0; commercial
NuSphere Nu-Coder - version 1.4; commercial

Mac OS X

skEdit
Smultron - version 1.0.1; freeware
TextWrangler
TextMate
Coda

Linux

Bluefish - version 1.0; other
Geany
gedit
gPHPEdit
Kate - version 2.2; freeware
Quanta Plus - version 3.2.1; freeware

Multiple OS

NetBeans
Eclipse
Aptana
Emacs - version 21; freeware
jEdit - version 4.1; freeware
SciTE - version 1.53; freeware
Vim - version 6.1; freeware
nano

.htaccess Password Protection

2009-01-27T20:29:00.000-08:00

Even without using mySQl, users can still password protect their files through .htaccess password protection.

The code can be divided into 3 if-else statements:

1. If the user has not been validated, use the PHP header and request for a username and password.

2. Else, if the user’s name is “webworld” and the password is “webworld”, log in. Here, all the code for the user will be placed.

3. Else say the user/password failed.

//1st part
if (!isset($PHP_AUTH_USER))
{
header("WWW-Authenticate: Basic realm=\"webworld Password.\"");
Header("HTTP/1.0 401 Unauthorized");
exit;
}

//2nd part
else if(($PHP_AUTH_USER=="webworld") && ($PHP_AUTH_PW=="webworld"))
{
echo "You are logged in...";
//put the code for the whole user page in here
//you can also create a redirect to the user page if you want
}

//3rd part
else
{
echo "Failed entry”;
//fail try again
}
?>

Remember that the username and password will remain for the whole session as long as explorer windows is open.

Notice: Unitialized string offset: 0 in XXX.php on line XXX

2008-12-31T16:56:00.000-08:00

Trying to convert PHP4 code to PHP5:

If ($key == $sort[$ri]) $reserved_violation = 1;

Any ideas on how to get rid of this notice without
turning notices off?

------------ --------- --------- ------
If ($key == @$sort[$ri]) $reserved_violation = 1;

------------ --------- --------- ------
Yep. Tried that. Still get same error.

Any other ideas?

------------ --------- --------- -----
If that didn't fix it then the problem is probably elsewhere in the code.

It is hard to say by looking at one line of code and not even knowing the variable types.

I can't see if $sort is STRING or ARRAY.

If type is STRING then the problem is that $ri > (strlen($sort) - 1) or $sort is unset

If type was intended to be ARRAY of STRING then the problem is that it is NULL

For STRING do this -
if(!isset($sort) ) $sort = '';
If ($key == @$sort[$ri]) $reserved_violation = 1;

or this -
if(!isset($sort) ) $sort = '';
if($ri < strlen($sort) )
{
If ($key == $sort[$ri]) $reserved_violation = 1;
// assuming strlen($key) == 1
}

For ARRAY of STRING do this -
if(!isset($sort[ $ri])) $sort[$ri] = '';
If ($key == @$sort[$ri]) $reserved_violation = 1;

or this -
if(!isset($sort[ $ri])) $sort[$ri] = '';
{
If ($key == $sort[$ri]) $reserved_violation = 1;
// assuming strlen($key) == 1
}

I think the problem is that $sort is NULL which probably means the problem is else where in the
code.

------------ --------- --------- --

PS: $string[$index] is zero indexed and strlen() is one indexed so -
if($ri < strlen($sort) )
should have been -
if($ri < (strlen($sort) - 1))

------------ --------- --------- --
Right you are! The variable was not initialized as
an array:

$sort = array();

Gotta remember to initialize variables. PHP5 is
not as forgiving as PHP4.

Thanks a bunch!

How to increase My SQL performance

2008-12-31T16:39:00.000-08:00

Hello All,
I have a "little problem". First of all, let me explain the problem.
I wrote a script to access My SQL database records in every second. I
used AJAX (Jquery) to fetch the records from database to refresh the
data on site with the records latest updated. When huge number of
users opens site, My SQL server cant response as usual and it goes
very slow (say halt stage).
I used CRON Tab to reduce the load of MY SQL but it also does not come
with solution.
So I hope some help from you people to complete the task.

Thanks in Advance
Narendra

---------------------------------------------------------------------------------------------
What kind of data needs to be updated on each client's browser every second? This seems a bit excessive at first glance.

AJAX can put a heavy load on the client machines if they are not the latest and greatest and have very fast Internet connections. For this and other reasons, AJAX should be used sparingly and when it can achieve a special desirable effect.

Are the applications for these multiple clients performing INSERT or UPDATE operations or merely SELECT operations? On MySQL, reads are gernerally very fast but you can get some table contention with lots of writes. An index on a table can speed up a SELECT but slow down an INSERT or UPDATE.

You could be running into an issue with the number of MySQL connections which may be open at any given time. Apache also has a maximum number of connections which may be reached with heavy usage.

You need to figure out where the bottleneck is in order to resolve it. This requires knowledge of the nature of your server, its operating system, its configuration, the queries you are running, the structure of the tables and indexes, etc.

James Keeline
------------------------------------------------------------------------------------------
------------ --------- --------- --
Hello James,
Many Thanks for your reply.
I am working on a site which is similar to auction site where users
can place a bid. When a user placed bid then all information for that
auction will be reflected on each users browser. It is clear that
users can bid at any time. So I have used AJAX to read records from My
SQL every second.
I want to make clear that most of the SQL used are SELECT statements
but they come up with joins to about 4 or 5 tables. Since I need to
display data after checking it in many tables for desirable conditions.
About server configurations, Ubuntu server with 2*2.4 processor, 2 GB
RAM etc.
Yes, of course MY SQL connection is opened for each user visiting a
site and will be closed after he/she close browser.

I hope now it is clear what I mean to ask.

Narendra
------------ --------- --------- ------
Hello,

I can't see any possible scalable solution to the way you are trying to achieve this at all.

Realty, if you do it this way not even 4 quad core CPU's is going to be enough! Not to mention that
2GB is lacking so say the least!

Time driven processing will not go down to minutes or second on a busy server. I think you need to
think about an event driven process that has some intelligence behind the timing of server
callbacks.

Not even eBay tries to get callbacks like this - it simply will not scale up as there simply needs
to be too many open connections right through your php to the database.

Pass some intelligence to the javascript so that callbacks are calculated and not every second.

Even if you have to have close callbacks at particular times then let the server regulate the
callbacks by passing the next callback period to the client so that you can regulate the load.

Are you using XML or JSON? For something like this you really need to fine tune things and XML is
far too bulky.

You really need to pass event objects from php to Javascript, I can't see any other way.

Also as someone else mentioned, if you are not very careful you will end up overloading the client
machine.

You can reduce the loading the SQL by importing more information into the session environment but
with 2GB - you will run into RAM issues very quickly. Why only 2GB? Is this a windoze based server?

If you can describe better what you want to do - with some detail to specific events the we can
probably help further.

Personally, I can't see a time based solution. I would be using the more advanced features of InnoDB
with an event driven client side under the general control of php rather than a time based bottle
neck.

Thanks.

JOB: PHP Web Developers in Irving Texas

2008-12-31T16:37:00.001-08:00

Chris Clary
O. 214.691.9494 x16
C. 972.571.6046
cclary@focalpointco rp.com

Chris is looking for a PHP Web Developers for a 3-6 month contract we
have open in Irving??

Step 9 - httpd.conf

2008-12-29T01:59:00.000-08:00

1) Using Windows Explorer navigate into the folder: C:\Program Files\Apache Software Foundation\Apache2.2\conf.

2) Open the file httpd.conf into a text editor (Notepad will work just fine.)

3) Scroll through the file until you hit the block with lots of LoadModule commands. They start on line 67.

4) Find the line that says:

#LoadModule rewrite_module modules/mod_rewrite.so

5) Remove the # from the start of the line (effectively un-commenting it). This will enable Mod Rewrite, useful for PHP frameworks such as CakePHP and the Zend Framework.

6) After the last LoadModule line (which should be the ssl_module) paste in the following block of text:

# PHP4
LoadModule php4_module "C:/php/php-4.4.7-Win32/php4apache2.dll"
PHPIniDir "C:/php/php-4.4.7-Win32"

# PHP5
#LoadModule php5_module "c:/php/php-5.2.3-Win32/php5apache2_2.dll"
#PHPIniDir "C:/php/php-5.2.3-Win32"

AddType application/x-httpd-php .php
AddType application/x-httpd-php-source .phps

This will tell Apache to use PHP 4. At the moment PHP 5 is commented out, but we'll enable it later on. The file should now look like this:

The image above shows PHP 5.2.2, yours will show 5.2.3

7) Carry on scrolling down the file until you get to this block of text:


  DirectoryIndex index.html

Change it to:


  DirectoryIndex index.php index.html

We've added index.php to the recognised list of 'index' pages for a web site. The files are searched for in the order in which they appear on the DirectoryIndex line, meaning that Apache will look for an index.php first, and if not found, it'll look for index.html next.

8) Finally scroll to almost the very bottom of the file where you will find these two lines:

# Virtual hosts
#Include conf/extra/httpd-vhosts.conf

Remove the # from the Include line so it looks like this:

# Virtual hosts
Include conf/extra/httpd-vhosts.conf

9) Save the httpd.conf file.

Step 8 - Install Apache2 Handler

2008-12-29T01:45:00.000-08:00

To use PHP 4 with Apache 2.2 you need to use an updated Apache2 Handler Module, and have the Visual C++ runtime components installed. This isn't as onerous as it sounds and won't take you more than a few minutes to do.

You should have downloaded the Visual C++ Redistributable at the start of this guide (either from the Apache Lounge web site, or as part of the CorePHP Bundle). This file is called vcredist_x86-sp1.exe. If you downloaded the CorePHP Bundle, you'll find the file inside the corephp_wamp_bundle_v1.zip file.

1) Double click vcredist_x86-sp1.exe.

2) The Microsoft Visual C++ Redistributable will run, install the files it requires and then exit silently.

3) You also downloaded the Apache2 Handler for PHP 4.4.7 created by the talented guys over at the Apache Lounge. This file is called php4apache2.dll-php4.4.x.zip. Unzip it to a folder on your PC. If you downloaded the CorePHP Bundle instead then you'll already have the files unzipped as they were included with the Visual C++ runtime above.

4) Copy the php4apache2.dll into C:\php\php-4.4.7-Win32:

5) Copy the httpd.exe.manifest into C:\Program Files\Apache Software Foundation\Apache2.2\bin:

Now we'll configure the httpd.conf.

Step 7 - Install Apache

2008-12-29T00:51:00.000-08:00

Before you start this process - do you already have a web server installed? For example IIS? If so then providing you don't require it, disable and/or uninstall it *prior* to installing Apache.

1) Double-click the apache_2.2.4-win32-x86-nossl.msi file to begin installation:

2) The Apache HTTP Server 2.2 installation wizard will appear, click Next to continue:

3) Accept the license agreement and click Next.

4) Read the Read me if you wish, and click Next to continue.

5) You will now enter some Server Information:

Network Domain: sandbox.dev
Server Name: www.sandbox.dev
Administrator's Email Address: enter your email address
Leave the install setting as for All Users, on Port 80, as a Service

It should look like this:

Click Next.

6) Leave the Setup Type as Typical and click Next:

7) Leave the Destination Folder as the default (C:\Program Files\Apache Software Foundation\Apache2.2\) and click Next:

8) On the Ready to Install the Program window, click Next:

9) After the installation has finished you will see the Installation Wizard Completed window, click Finish:

10) You now have a new icon in your system tray that looks like the Apache feather with a white circle and a green arrow in it (see image below). This is the Apache Service Monitor and we'll use it to stop and start Apache when setting up PHP.

11) If you have this icon then Apache is running. To demonstrate this open up your web browser and go to http://localhost/. The 'It works!' message will greet you:

Sometimes you may need to reboot your PC after installing Apache, if it doesn't run right away, do this. We're now ready to set-up Apache for PHP.

Step 6 - Setting the Environment Variable

2008-12-28T14:59:00.000-08:00

1) Right-click on your My Computer icon on your Desktop and select Properties.

2) The System Properties window will appear. Click the Advanced tab:

3) At the bottom left, click the Environment Variables button:

4) The Environment Variables window will appear:

5) In the bottom half you'll see the System variables.
Find the Variable called Path, select it and then click the Edit button:

6) The Edit System Variable window will appear.

7) The Variable value will be automatically selected. Press the End key on your keyboard to jump to the end of the line, deselecting all the text in the process (make sure you don't accidentally delete any). Now add the following text to the END of the current path text:

;C:\php\php-4.4.7-Win32;C:\php\php-5.2.3-Win32

7) It is important that the two paths and the previous values are separated by semi-colons. The end result should look like this:

The image above shows PHP 5.2.2, yours will show 5.2.3

Take extra special care not to delete or remove anything that already existed on the Path line. The text you added should be appended to whatever was there already. Deleting previous entries can cause some Windows applications to stop working completely.

8) Click OK to close the Edit System Variable window. Click OK to close the Environment Variables window. Click OK to close the System Properties window.

9) Reboot your PC. I'm afraid it is vitally important that you reboot now before we go any further. As annoying as it is, please don't skip this step or PHP won't work properly.

Step 5 - Create a local web site

2008-12-27T14:50:00.000-08:00

1) Create a folder where you want your web sites to live. This doesn't have to be on the same drive as Apache. For the sake of this guide we're going to assume that our web sites live in C:\www, so create the folder C:\www.

2) Our test site is called sandbox.dev, so create the new folder C:\www\sandbox.dev.

3) We now need two more folders, one for the web site files to go in, and one for the Apache log files (very useful for error trapping). So within C:\www\sandbox.dev create two folders, one called public_html and one called www_logs. The 'public_html' folder is what most software applications call your 'webroot'. If it makes it easier for you to remember, you can name it this (just remember to reflect this change through-out the rest of the guide)

4) The final directory structure should look like this:

5) Go into the public_html folder and create a new file called index.php.

6) Place the following code into the index.php file:

7) Save index.php.

Step 4 - PHP 5 Settings

2008-12-26T19:26:00.000-08:00

1) Using Windows Explorer navigate into the C:\php\php-5.2.3-Win32 folder.

2) Rename the file php.ini-dist to php.ini.

3) Open php.ini into Notepad (or a text editor of your choice)

4) For now we're only going to configure the PHP values that we need in order to get PHP running, you can come back into the php.ini file at a later stage to fine-tune as you require but right now please do just the following:

5) Search for the line:

log_errors = Off

and change it to:

log_errors = On

6) Search for the line:

extension_dir = "./"

and change it to:

extension_dir = "C:/php/php-5.2.3-Win32/ext"

7) Save the php.ini file. Please don't be tempted to change anything else right now, you'll get plenty of time to do that once PHP and Apache are working flawlessly together.

Step 3 - PHP 4 Settings

2008-12-26T17:23:00.000-08:00

1) Using Windows Explorer navigate into the C:\php\php-4.4.7-Win32 folder.

2) Rename the file php.ini-dist to php.ini

3) Open php.ini into Notepad (or a text editor of your choice)

5) Search for the line:

log_errors = Off

and change it to:

log_errors = On

6) Search for the line:

extension_dir = "./"

and change it to:

extension_dir = "C:/php/php-4.4.7-Win32/extensions"

7) Save the php.ini file. Please don't be tempted to change anything else right now, you'll get plenty of time to do that once PHP and Apache are working flawlessly together.

Step 2 - Configure Windows XP for PHP

2008-12-26T16:21:00.000-08:00

1) Create a folder on the root of your C:\ drive called php. If you wish to create the folder on another drive that is fine, but we will assume C:\ through-out the rest of this guide, so if you install elsewhere make sure you change the drive letter accordingly.

2) Copy the php-4.4.7-Win32.zip and php-5.2.3-Win32.zip files into C:\php.

The image above shows PHP 5.2.2, yours will show 5.2.3

3) Unzip both files, keeping the folder structures intact.

If you don't have a zip utility installed (such as Winzip or WinRAR) then click here to show instructions on unzipping the files using Windows 'Compressed Folders' feature.

4) You will have the following directory structure:

The image above shows PHP 5.2.2, yours will show 5.2.3

If for some reason you don't, move the folders around as required until it matches the screen shot above exactly.

Step 1 - Downloads

2008-12-26T15:18:00.000-08:00

The first thing to do is download all the files we're going to need. The Download Links will download the files. The Web Page link will take you to the page that hosts the file so you can verify its source.

Download Link	Filename	Size	Web Page
PHP 5.2.3 zip package	php-5.2.3-Win32.zip	9.8 MB	go to
PHP 4.4.7 zip package	php-4.4.7-Win32.zip	8.4 MB	go to
Apache 2.2.4	apache_2.2.4-win32-x86-no_ssl.msi	4.2 MB	go to
Apache2 Handler for PHP 4.4.7	php4apache2.dll-php4.4.x.zip	13 KB	go to
Visual C++ 2005 Redistributable	vcredist_x86-sp1.exe	2.6 MB	go to
Host Administrator Utility	hostadm.exe	213 KB	go to

CorePHP Bundle

The bottom three files on the list above are hosted on personal web sites, and I cannot guarantee that they will always be available. Therefore I have bundled them all together in a single zip file. This contains the Apache2 Handler for PHP 4.4.7, the Visual C++ 2005 Redistributable and the Host Administrator utility. Should the above download links fail you can get this bundle instead: Download the CorePHP WAMP Bundle (2.6 MB)

comprehensive guide to installing and running Apache with PHP on Windows

2008-12-26T14:16:00.000-08:00

This is a comprehensive guide to installing and running Apache 2.2.4 with PHP 4.4.7 and PHP 5.2.3 on Windows XP. It covers all of the steps in detail with lots of screen grabs so you can follow the process visually.

The Guide

I know that the number of sections looks daunting, but that is because I have split the guide up into small manageable chunks. It shouldn't take you longer than a couple of minutes to complete each section.

Useful Extras

PHP 2.5.8. Update

2008-12-13T20:06:00.000-08:00

It’s that time of the month to check if there’s a new update for PHP and (gasp!) there is one!

Due to a security bug found in the PHP 5.2.7 release, it has been removed from distribution. The bug affects configurations where magic_quotes_gpc is enabled, because it remains off even when set to on. In the meantime, use PHP 5.2.6 until PHP 5.2.8 is later released.

The PHP Development Team would like to announce the immediate availability of PHP 5.2.8. This release addresses a regression introduced by 5.2.7 in regard to the magic_quotes functionality, which was broken by an incorrect fix to the filter extension. All users who have upgraded to 5.2.7 are encouraged to upgrade to this release. Alternatively you can apply a work-around for the bug by changing â€œfilter.default_flags=0â€³ in php.ini.

Go ahead and update this one right away as it will save your IT hide.

Source

PHP Hypertext Preprocessor

[PHP Classes] : Simpled thumbnail

class: Simpled thumbnail

Class:

Short description:

Groups:

Supplied by:

Detailed description:

[PHP Classes] Added a new class: Chinese Character Conversion

Short description:

Groups:

Supplied by:

Detailed description:

[PHP Classes] Added a new class: PID process check

Short description:

Groups:

Supplied by:

Detailed description:

[PHP Classes] Added a new class: Binary Array

Short description:

Groups:

Supplied by:

Detailed description:

[PHP Classes] Added a new class: SaffRequest

Class:

Short description:

Groups:

Supplied by:

Detailed description:

[PHP Classes] Added a new class: XML-Writer

Class:

Short description:

Groups:

Supplied by:

Detailed description:

[PHP Classes] Innovation Award results of March of 2011

[PHP Classes] Added a new class: Simple Zend View XSLT

Class:

Short description:

Groups:

Supplied by:

Detailed description:

[PHP Classes] Added a new class: Plinq

Class:

Short description:

Groups:

Supplied by:

Detailed description:

[PHP Classes] PHP built-in Web server, PHP 5.3.6 and PHP.JS - Lately in PHP podcast episode 10

A new post was published in PHP Classes blogPHP built-in Web server, PHP 5.3.6 and PHP.JS - Lately in PHP podcast episode 10

[PHP Classes] Added a new class: Cyber MySQL PDO

Class:

Short description:

Groups:

Supplied by:

Detailed description:

[PHP Classes] Added a new class: ABG PHP To XLS

[PHP Classes] Weekly newsletter of Monday - 2011-03-28

[PHP Classes] Added a new class: Persian Calendar date function

[PHP Classes] Added a new class: Similarities Finder

[PHP Classes] Added a new class: Page Header

[PHP Classes] Added a new class: Debugging Made Easy

[PHP Classes] Added a new class: Leopard Validator

[PHP Classes] Added a new class: cCaptcha

[PHP Classes] The Fastest Ways to Deliver Email in PHP

[PHP Classes] Added a new class: Estoy Database system

[PHP Classes] Added a new class: NYOS_ExcelWriter_simple

ArrayQry

ArrayQry

Short description:

Groups:

Supplied by:

Detailed description:

Hijri To Gregorian Date Convert

Hijri To Gregorian Date Convert

Short description:

Groups:

Supplied by:

Detailed description:

Simple XML Array Helper

A new post was published in PHP Classes blog

PHP built-in Web server, PHP 5.3.6 and PHP.JS - Lately in PHP podcast episode 10