Showing posts with label Language Reference PHP. Show all posts

mail

(PHP 3, PHP 4, PHP 5)
mail -- Send mail

Description

bool mail ( string to, string subject, string message [, string additional_headers [, string additional_parameters]] )
Sends an email.

Parameters

to

Receiver, or receivers of the mail. The formatting of this string must comply with RFC 2822. Some examples are:

user@example.com

user@example.com, anotheruser@example.com

User <user@example.com>

User <user@example.com>, Another User <anotheruser@example.com>

subject

Subject of the email to be sent.

This must not contain any newline characters, or the mail may not be sent properly.

message

Message to be sent.

Each line should be separated with a LF (\n). Lines should not be larger than 70 characters.

(Windows only) When PHP is talking to a SMTP server directly, if a full stop is found on the start of a line, it is removed. To counter-act this, replace these occurrences with a double dot.

<?php

$text = str_replace("\n.", "\n..", $text);?>

additional_headers (optional)

String to be inserted at the end of the email header. This is typically used to add extra headers (From, Cc, and Bcc). Multiple extra headers should be separated with a CRLF (\r\n).

When sending mail, the mail must contain a From header. This can be set with the additional_headers parameter, or a default can be set in php.ini. Failing to do this will result in an error message similar to Warning: mail(): "sendmail_from" not set in php.ini or custom "From:" header missing. The From header sets also Return-Path under Windows.

If messages are not received, try using a LF (\n) only. Some poor quality Unix mail transfer agents replace LF by CRLF automatically (which leads to doubling CR if CRLF is used). This should be a last resort, as it does not comply with RFC 2822.

additional_parameters (optional)

The additional_parameters parameter can be used to pass an additional parameter to the program configured to use when sending mail using the sendmail_path configuration setting. For example, this can be used to set the envelope sender address when using sendmail with the -f sendmail option. The user that the webserver runs as should be added as a trusted user to the sendmail configuration to prevent a 'X-Warning' header from being added to the message when the envelope sender (-f) is set using this method. For sendmail users, this file is /etc/mail/trusted-users.

Return Values

Returns TRUE if the mail was successfully accepted for delivery, FALSE otherwise.
It is important to note that just because the mail was accepted for delivery, it does NOT mean the mail will actually reach the intended destination.

ChangeLog

Version	Description
4.3.0 (Windows only)	All custom headers (like From, Cc, Bcc and Date) are supported, and are not case-sensitive. (As custom headers are not interpreted by the MTA in the first place, but are parsed by PHP, PHP < 4.3 only supported the Cc header element and was case-sensitive).
4.2.3	The `additional_parameters` parameter is disabled in safe_mode and the mail() function will expose a warning message and return `FALSE` when used.
4.0.5	The `additional_parameters` parameter was added.

Examples

Sending mail.
Using mail() to send a simple email:

<?php// The message$message = "Line 1\nLine 2\nLine 3";

// In case any of our lines are larger than 70 characters, we should use wordwrap()$message = wordwrap($message, 70);

// Sendmail('caffinated@example.com', 'My Subject', $message);?>

Sending mail with extra headers.
The addition of basic headers, telling the MUA the From and Reply-To addresses:

<?php

$to      = 'nobody@example.com';$subject = 'the subject';$message = 'hello';$headers = 'From: webmaster@example.com' . "\r\n" .

'Reply-To: webmaster@example.com' . "\r\n" .

'X-Mailer: PHP/' . phpversion();

mail($to, $subject, $message, $headers);?>

Sending mail with an additional command line parameter.
The additional_parameters parameter can be used to pass an additional parameter to the program configured to use when sending mail using the sendmail_path.

<?php

mail('nobody@example.com', 'the subject', 'the message', null,

'-fwebmaster@example.com');?>

Sending HTML email
It is also possible to send HTML email with mail().

<?php// multiple recipients$to  = 'aidan@example.com' . ', '; // note the comma$to .= 'wez@example.com';

// subject$subject = 'Birthday Reminders for August';

// message$message = '

<html>

<head>

<title>Birthday Reminders for August</title>

</head>

<body>

<p>Here are the birthdays upcoming in August!</p>

<table>

<tr>

<th>Person</th><th>Day</th><th>Month</th><th>Year</th>

</tr>

<tr>

<td>Joe</td><td>3rd</td><td>August</td><td>1970</td>

</tr>

<tr>

<td>Sally</td><td>17th</td><td>August</td><td>1973</td>

</tr>

</table>

</body>

</html>

';

// To send HTML mail, the Content-type header must be set$headers  = 'MIME-Version: 1.0' . "\r\n";$headers .= 'Content-type: text/html; charset=iso-8859-1' . "\r\n";

// Additional headers$headers .= 'To: Mary <mary@example.com>, Kelly <kelly@example.com>' . "\r\n";$headers .= 'From: Birthday Reminder <birthday@example.com>' . "\r\n";$headers .= 'Cc: birthdayarchive@example.com' . "\r\n";$headers .= 'Bcc: birthdaycheck@example.com' . "\r\n";

// Mail itmail($to, $subject, $message, $headers);?>

If intending to send HTML or otherwise Complex mails, it is recommended to use the PEAR package PEAR::Mail.

Notes

The Windows implementation of mail() differs in many ways from the Unix implementation. First, it doesn't use a local binary for composing messages but only operates on direct sockets which means a MTA is needed listening on a network socket (which can either on the localhost or a remote machine).
Second, the custom headers like From:, Cc:, Bcc: and Date: are not interpreted by the MTA in the first place, but are parsed by PHP.
As such, the to parameter should not be an address in the form of "Something <someone@example.com>". The mail command may not parse this properly while talking with the MTA.

Email with attachments and special types of content (e.g. HTML) can be sent using this function. This is accomplished via MIME-encoding - for more information, see this Zend article or the PEAR Mime Classes.

It is worth noting that the mail() function is not suitable for larger volumes of email in a loop. This function opens and closes an SMTP socket for each email, which is not very efficient.
For the sending of large amounts of email, see the PEAR::Mail, and PEAR::Mail_Queue packages.

The following RFCs may be useful: RFC 1896, RFC 2045, RFC 2046, RFC 2047, RFC 2048, RFC 2049, and RFC 2822.

This file was generated: Tue May 30 00:15:09 2006
Go to http://www.php.net/docs.php to get the actual version.

Read more »

ezmlm_hash

No comments

ezmlm_hash

(PHP 3 >= 3.0.17, PHP 4 >= 4.0.2, PHP 5)
ezmlm_hash -- Calculate the hash value needed by EZMLM

Description

int ezmlm_hash ( string addr )
ezmlm_hash() calculates the hash value needed when keeping EZMLM mailing lists in a MySQL database.

Parameters

addr: The email address that's being hashed.

Return Values

The hash value of addr.

Examples ezmlm_hash

Calculating the hash and subscribing a user

<?php



$user = "joecool@example.com";$hash = ezmlm_hash($user);$query = sprintf("INSERT INTO sample VALUES (%s, '%s')", $hash, $user);$db->query($query); // using PHPLIB db interface

?>

This file was generated: Tue May 30 00:15:09 2006
Go to http://www.php.net/docs.php to get the actual version.

Read more »

PHP type comparison tables

2 comments

PHP type comparison tables. The following tables demonstrate behaviors of PHP types and comparison operators, for both loose and strict comparisons. This supplemental is also related to the manual section on type juggling. Inspiration was provided by various user comments and by the work over at BlueShoes.
Before utilizing these tables, it's important to understand types and their meanings. For example, "42" is a string while 42 is an integer. FALSE is a boolean while "false" is a string.

HTML Forms do not pass integers, floats, or booleans; they pass strings. To find out if a string is numeric, you may use is_numeric().

Simply doing if ($x) while $x is undefined will generate an error of level E_NOTICE. Instead, consider using empty() or isset() and/or initialize your variables.

PHP type comparison tables

Comparisons of $x with PHP functions

Expression	gettype()	empty()	is_null()	isset()	boolean : `if($x)`
`$x = "";`	string	`TRUE`	`FALSE`	`TRUE`	`FALSE`
`$x = NULL`	NULL	`TRUE`	`TRUE`	`FALSE`	`FALSE`
`var $x;`	NULL	`TRUE`	`TRUE`	`FALSE`	`FALSE`
`$x` is undefined	NULL	`TRUE`	`TRUE`	`FALSE`	`FALSE`
`$x = array();`	array	`TRUE`	`FALSE`	`TRUE`	`FALSE`
`$x = false;`	boolean	`TRUE`	`FALSE`	`TRUE`	`FALSE`
`$x = true;`	boolean	`FALSE`	`FALSE`	`TRUE`	`TRUE`
`$x = 1;`	integer	`FALSE`	`FALSE`	`TRUE`	`TRUE`
`$x = 42;`	integer	`FALSE`	`FALSE`	`TRUE`	`TRUE`
`$x = 0;`	integer	`TRUE`	`FALSE`	`TRUE`	`FALSE`
`$x = -1;`	integer	`FALSE`	`FALSE`	`TRUE`	`TRUE`
`$x = "1";`	string	`FALSE`	`FALSE`	`TRUE`	`TRUE`
`$x = "0";`	string	`TRUE`	`FALSE`	`TRUE`	`FALSE`
`$x = "-1";`	string	`FALSE`	`FALSE`	`TRUE`	`TRUE`
`$x = "php";`	string	`FALSE`	`FALSE`	`TRUE`	`TRUE`
`$x = "true";`	string	`FALSE`	`FALSE`	`TRUE`	`TRUE`
`$x = "false";`	string	`FALSE`	`FALSE`	`TRUE`	`TRUE`

Loose comparisons with ==

	`TRUE`	`FALSE`	`1`	`0`	`-1`	`"1"`	`"0"`	`"-1"`	`NULL`	`array()`	`"php"`
`TRUE`	`TRUE`	`FALSE`	`TRUE`	`FALSE`	`TRUE`	`TRUE`	`FALSE`	`TRUE`	`FALSE`	`FALSE`	`TRUE`
`FALSE`	`FALSE`	`TRUE`	`FALSE`	`TRUE`	`FALSE`	`FALSE`	`TRUE`	`FALSE`	`TRUE`	`TRUE`	`FALSE`
`1`	`TRUE`	`FALSE`	`TRUE`	`FALSE`	`FALSE`	`TRUE`	`FALSE`	`FALSE`	`FALSE`	`FALSE`	`FALSE`
`0`	`FALSE`	`TRUE`	`FALSE`	`TRUE`	`FALSE`	`FALSE`	`TRUE`	`FALSE`	`TRUE`	`FALSE`	`TRUE`
`-1`	`TRUE`	`FALSE`	`FALSE`	`FALSE`	`TRUE`	`FALSE`	`FALSE`	`TRUE`	`FALSE`	`FALSE`	`FALSE`
`"1"`	`TRUE`	`FALSE`	`TRUE`	`FALSE`	`FALSE`	`TRUE`	`FALSE`	`FALSE`	`FALSE`	`FALSE`	`FALSE`
`"0"`	`FALSE`	`TRUE`	`FALSE`	`TRUE`	`FALSE`	`FALSE`	`TRUE`	`FALSE`	`FALSE`	`FALSE`	`FALSE`
`"-1"`	`TRUE`	`FALSE`	`FALSE`	`FALSE`	`TRUE`	`FALSE`	`FALSE`	`TRUE`	`FALSE`	`FALSE`	`FALSE`
`NULL`	`FALSE`	`TRUE`	`FALSE`	`TRUE`	`FALSE`	`FALSE`	`FALSE`	`FALSE`	`TRUE`	`TRUE`	`FALSE`
`array()`	`FALSE`	`TRUE`	`FALSE`	`FALSE`	`FALSE`	`FALSE`	`FALSE`	`FALSE`	`TRUE`	`TRUE`	`FALSE`
`"php"`	`TRUE`	`FALSE`	`FALSE`	`TRUE`	`FALSE`	`FALSE`	`FALSE`	`FALSE`	`FALSE`	`FALSE`	`TRUE`

Strict comparisons with ===

	`TRUE`	`FALSE`	`1`	`0`	`-1`	`"1"`	`"0"`	`"-1"`	`NULL`	`array()`	`"php"`
`TRUE`	`TRUE`	`FALSE`	`FALSE`	`FALSE`	`FALSE`	`FALSE`	`FALSE`	`FALSE`	`FALSE`	`FALSE`	`FALSE`
`FALSE`	`FALSE`	`TRUE`	`FALSE`	`FALSE`	`FALSE`	`FALSE`	`FALSE`	`FALSE`	`FALSE`	`FALSE`	`FALSE`
`1`	`FALSE`	`FALSE`	`TRUE`	`FALSE`	`FALSE`	`FALSE`	`FALSE`	`FALSE`	`FALSE`	`FALSE`	`FALSE`
`0`	`FALSE`	`FALSE`	`FALSE`	`TRUE`	`FALSE`	`FALSE`	`FALSE`	`FALSE`	`FALSE`	`FALSE`	`FALSE`
`-1`	`FALSE`	`FALSE`	`FALSE`	`FALSE`	`TRUE`	`FALSE`	`FALSE`	`FALSE`	`FALSE`	`FALSE`	`FALSE`
`"1"`	`FALSE`	`FALSE`	`FALSE`	`FALSE`	`FALSE`	`TRUE`	`FALSE`	`FALSE`	`FALSE`	`FALSE`	`FALSE`
`"0"`	`FALSE`	`FALSE`	`FALSE`	`FALSE`	`FALSE`	`FALSE`	`TRUE`	`FALSE`	`FALSE`	`FALSE`	`FALSE`
`"-1"`	`FALSE`	`FALSE`	`FALSE`	`FALSE`	`FALSE`	`FALSE`	`FALSE`	`TRUE`	`FALSE`	`FALSE`	`FALSE`
`NULL`	`FALSE`	`FALSE`	`FALSE`	`FALSE`	`FALSE`	`FALSE`	`FALSE`	`FALSE`	`TRUE`	`FALSE`	`FALSE`
`array()`	`FALSE`	`FALSE`	`FALSE`	`FALSE`	`FALSE`	`FALSE`	`FALSE`	`FALSE`	`FALSE`	`TRUE`	`FALSE`
`"php"`	`FALSE`	`FALSE`	`FALSE`	`FALSE`	`FALSE`	`FALSE`	`FALSE`	`FALSE`	`FALSE`	`FALSE`	`TRUE`

PHP 3.0 note: The string value "0" was considered non-empty in PHP 3, this behavior changed in PHP 4 where it's now seen as empty.

Read more »

PHP Navigations

No comments

PHP Navigations

<?php
if($_SERVER['QUERY_STRING'] == "SoD")
print "owns you!";
else
print "don't front!";
?>

Description: Instead of calling files like ( index.php?str=blah ) , you could do ( index.php?SoD ) and it would print out "owns you!". You can add more strings in there, this is just an example.

   $vars = explode(",", urldecode(getenv('QUERY_STRING')));
   $v1 = array_shift($vars);
   $v2 = array_shift($vars);
   $v3 = array_shift($vars);

   switch ($v1) {
       case 'first.1': {
           print("This is v1, first string case 'file.php?first.1'.");
           break;
           }
      case 'first.2': {
      switch ($v2) {
           case 'second': {
               switch($v3) {
                   case 'third': {
                     print("This is v3, the last case 'file.php?first.2,second,third'.");
                     break;
                   }
               }
           }
       }
       }
   }

Description: This basically does what the 1st one does but with more strings and a different seperator rather than '&'. I don't really want to go into too much detail on the thread so if people are confused or need explaining.

That's it for the navigation as I am not going to do the other due to they're everywhere else and I wanted to be different and show everyone this method.

PHP Navigations williwacker-www.softarchive.net

Read more »

HTTP authentication with PHP

1 comment

HTTP authentication with PHP

It is possible to use the header() function to send an "Authentication Required" message to the client browser causing it to pop up a Username/Password input window. Once the user has filled in a username and a password, the URL containing the PHP script will be called again with the predefined variablesPHP_AUTH_USER, PHP_AUTH_PW, and AUTH_TYPE set to the user name, password and authentication type respectively. These predefined variables are found in the $_SERVER and $HTTP_SERVER_VARS arrays. Both "Basic" and "Digest" (since PHP 5.1.0) authentication methods are supported. See the header() function for more information.

Note: PHP Version Note

Superglobals, such as $_SERVER, became available in PHP » 4.1.0.

HTTP authentication with PHP

An example script fragment which would force client authentication on a page is as follows:

Example #1 Basic HTTP Authentication example

<?phpif (!isset($_SERVER['PHP_AUTH_USER'])) {

    header('WWW-Authenticate: Basic realm="My Realm"');

    header('HTTP/1.0 401 Unauthorized');

    echo 'Text to send if user hits Cancel button';

    exit;

} else {

    echo "<p>Hello {$_SERVER['PHP_AUTH_USER']}.</p>";

    echo "<p>You entered {$_SERVER['PHP_AUTH_PW']} as your password.</p>";

}?>

Example #2 Digest HTTP Authentication example

This example shows you how to implement a simple Digest HTTP authentication script. For more information read the » RFC 2617.

<?php

$realm = 'Restricted area';

//user => password$users = array('admin' => 'mypass', 'guest' => 'guest');





if (empty($_SERVER['PHP_AUTH_DIGEST'])) {

    header('HTTP/1.1 401 Unauthorized');

    header('WWW-Authenticate: Digest realm="'.$realm.

           '",qop="auth",nonce="'.uniqid().'",opaque="'.md5($realm).'"');



    die('Text to send if user hits Cancel button');

}



// analyze the PHP_AUTH_DIGEST variableif (!($data = http_digest_parse($_SERVER['PHP_AUTH_DIGEST'])) ||

    !isset($users[$data['username']]))

    die('Wrong Credentials!');



// generate the valid response$A1 = md5($data['username'] . ':' . $realm . ':' . $users[$data['username']]);$A2 = md5($_SERVER['REQUEST_METHOD'].':'.$data['uri']);$valid_response = md5($A1.':'.$data['nonce'].':'.$data['nc'].':'.$data['cnonce'].':'.$data['qop'].':'.$A2);



if ($data['response'] != $valid_response)

    die('Wrong Credentials!');

// ok, valid username & passwordecho 'You are logged in as: ' . $data['username'];



// function to parse the http auth headerfunction http_digest_parse($txt)

{

    // protect against missing data

    $needed_parts = array('nonce'=>1, 'nc'=>1, 'cnonce'=>1, 'qop'=>1, 'username'=>1, 'uri'=>1, 'response'=>1);

    $data = array();

    $keys = implode('|', array_keys($needed_parts));



    preg_match_all('@(' . $keys . ')=(?:([\'"])([^\2]+?)\2|([^\s,]+))@', $txt, $matches, PREG_SET_ORDER);



    foreach ($matches as $m) {

        $data[$m[1]] = $m[3] ? $m[3] : $m[4];

        unset($needed_parts[$m[1]]);

    }



    return $needed_parts ? false : $data;

}?>

Note: Compatibility Note

Please be careful when coding the HTTP header lines. In order to guarantee maximum compatibility with all clients, the keyword "Basic" should be written with an uppercase "B", the realm string must be enclosed in double (not single) quotes, and exactly one space should precede the 401 code in the HTTP/1.0 401 header line. Authentication parameters have to be comma-separated as seen in the digest example above.

Instead of simply printing out PHP_AUTH_USER and PHP_AUTH_PW, as done in the above example, you may want to check the username and password for validity. Perhaps by sending a query to a database, or by looking up the user in a dbm file.

Watch out for buggy Internet Explorer browsers out there. They seem very picky about the order of the headers. Sending the WWW-Authenticate header before the HTTP/1.0 401 header seems to do the trick for now.

As of PHP 4.3.0, in order to prevent someone from writing a script which reveals the password for a page that was authenticated through a traditional external mechanism, the PHP_AUTH variables will not be set if external authentication is enabled for that particular page and safe mode is enabled. Regardless, REMOTE_USER can be used to identify the externally-authenticated user. So, you can use $_SERVER['REMOTE_USER'].

Note: Configuration Note

PHP uses the presence of an AuthType directive to determine whether external authentication is in effect.

Note, however, that the above does not prevent someone who controls a non-authenticated URL from stealing passwords from authenticated URLs on the same server.

Both Netscape Navigator and Internet Explorer will clear the local browser window's authentication cache for the realm upon receiving a server response of 401. This can effectively "log out" a user, forcing them to re-enter their username and password. Some people use this to "time out" logins, or provide a "log-out" button.

Example #3 HTTP Authentication example forcing a new name/password

<?phpfunction authenticate() {

    header('WWW-Authenticate: Basic realm="Test Authentication System"');

    header('HTTP/1.0 401 Unauthorized');

    echo "You must enter a valid login ID and password to access this resource\n";

    exit;

}



if (!isset($_SERVER['PHP_AUTH_USER']) ||

    ($_POST['SeenBefore'] == 1 && $_POST['OldAuth'] == $_SERVER['PHP_AUTH_USER'])) {

    authenticate();

} else {

    echo "<p>Welcome: " . htmlspecialchars($_SERVER['PHP_AUTH_USER']) . "<br />";

    echo "Old: " . htmlspecialchars($_REQUEST['OldAuth']);

    echo "<form action='' method='post'>\n";

    echo "<input type='hidden' name='SeenBefore' value='1' />\n";

    echo "<input type='hidden' name='OldAuth' value=\"" . htmlspecialchars($_SERVER['PHP_AUTH_USER']) . "\" />\n";

    echo "<input type='submit' value='Re Authenticate' />\n";

    echo "</form></p>\n";

}?>

This behavior is not required by the HTTP Basic authentication standard, so you should never depend on this. Testing with Lynx has shown that Lynx does not clear the authentication credentials with a 401 server response, so pressing back and then forward again will open the resource as long as the credential requirements haven't changed. The user can press the '_' key to clear their authentication information, however.

Also note that until PHP 4.3.3, HTTP Authentication did not work using Microsoft's IIS server with the CGI version of PHP due to a limitation of IIS. In order to get it to work in PHP 4.3.3+, you must edit your IIS configuration "Directory Security". Click on "Edit" and only check "Anonymous Access", all other fields should be left unchecked.

Another limitation is if you're using the IIS module (ISAPI) and PHP 4, you may not use the PHP_AUTH_*HTTP_AUTHORIZATION is available. For example, consider the following code: list($user, $pw) = explode(':', base64_decode(substr($_SERVER['HTTP_AUTHORIZATION'], 6))); variables but instead, the variable

Note: IIS Note:
For HTTP Authentication to work with IIS, the PHP directive cgi.rfc2616_headers must be set to 0 (the default value).

Note:

If safe mode is enabled, the uid of the script is added to the realm part of the WWW-Authenticate header.

Read more »

Debugger Protocol PHP

1 comment

Debugging PHP
Using the Debugger PHP
Debugger Protocol PHP

Debugger Protocol PHP

The PHP 3 debugger protocol is line-based. Each line has a type, and several lines compose a message. Each message starts with a line of the type start and terminates with a line of the type end. PHP 3 may send lines for different messages simultaneously.

A line has this format:

date time host(pid) type: message-data

date

Date in ISO 8601 format (yyyy-mm-dd)

time

Time including microseconds: hh:mm:uuuuuu

host

DNS name or IP address of the host where the script error was generated.

pid

PID (process id) on host of the process with the PHP 3 script that generated this error.

type

Type of line. Tells the receiving program about what it should treat the following data as:

Debugger Line Types

Name	Meaning
`start`	Tells the receiving program that a debugger message starts here. The contents of `data` will be the type of error message, listed below.
`message`	The PHP 3 error message.
`location`	File name and line number where the error occurred. The first `location` line will always contain the top-level location. `data` will contain `file:line`. There will always be a `location` line after `message` and after every `function`.
`frames`	Number of frames in the following stack dump. If there are four frames, expect information about four levels of called functions. If no "frames" line is given, the depth should be assumed to be 0 (the error occurred at top-level).
`function`	Name of function where the error occurred. Will be repeated once for every level in the function call stack.
`end`	Tells the receiving program that a debugger message ends here.

data

Line data.

Debugger Error Types

Debugger	PHP 3 Internal
warning	E_WARNING
error	E_ERROR
parse	E_PARSE
notice	E_NOTICE
core-error	E_CORE_ERROR
core-warning	E_CORE_WARNING
unknown	(any other)

Example Debugger Message

1998-04-05 23:27:400966 lucifer.guardian.no(20481) start: notice
1998-04-05 23:27:400966 lucifer.guardian.no(20481) message: Uninitialized variable
1998-04-05 23:27:400966 lucifer.guardian.no(20481) location: (null):7
1998-04-05 23:27:400966 lucifer.guardian.no(20481) frames: 1
1998-04-05 23:27:400966 lucifer.guardian.no(20481) function: display
1998-04-05 23:27:400966 lucifer.guardian.no(20481) location: /home/ssb/public_html/test.php3:10
1998-04-05 23:27:400966 lucifer.guardian.no(20481) end: notice

Read more »

Debugging PHP

1 comment

Debugging PHP
Using the Debugger PHP
Debugger Protocol PHP

About Debugging PHP

PHP 3 includes support for a network-based debugger.
PHP 4 does not have an internal debugging facility. You can use one of the external debuggers though. The Zend IDE includes a debugger, and there are also some free debugger extensions like DBG at http://dd.cron.ru/dbg/, the Advanced PHP Debugger (APD) or Xdebug which even has a compatible debugger interface as PHP 3's debugging functionality as is described in this section.

Read more »

Using the Debugger PHP

No comments

Debugging PHP
Using the Debugger PHP
Debugger Protocol PHP

Using the Debugger PHP

The internal debugger in PHP 3 is useful for tracking down evasive bugs. The debugger works by connecting to a TCP port for every time PHP 3 starts up. All error messages from that request will be sent to this TCP connection. This information is intended for "debugging server" that can run inside an IDE or programmable editor (such as Emacs).
How to set up the debugger:

Set up a TCP port for the debugger in the configuration file (debugger.port) and enable it (debugger.enabled).
Set up a TCP listener on that port somewhere (for example socket -l -s 1400 on Unix systems).
In your code, run "debugger_on(host)", where host is the IP number or name of the host running the TCP listener.

Now, all warnings, notices etc. will show up on that listener socket, even if you turned them off with error_reporting().

Read more »

History of PHP related projects

1 comment

History of PHP
History of PHP related projects
Books about PHP
Publications about PHP

History of PHP related projects

PEAR

PEAR, the PHP Extension and Application Repository (originally, PHP Extension and Add-on Repository) is PHP's version of foundation classes, and may grow in the future to be one of the key ways to distribute PHP extensions among developers.
PEAR was born in discussions held in the PHP Developers' Meeting (PDM) held in January 2000 in Tel Aviv. It was created by Stig S. Bakken, and is dedicated to his first-born daughter, Malin Bakken.
Since early 2000, PEAR has grown to be a big, significant project with a large number of developers working on implementing common, reusable functionality for the benefit of the entire PHP community. PEAR today includes a wide variety of infrastructure foundation classes for database access, content caching, mathematical calculations, eCommerce and much more.
More information about PEAR can be found in the manual.

PHP Quality Assurance Initiative

The PHP Quality Assurance Initiative was set up in the summer of 2000 in response to criticism that PHP releases were not being tested well enough for production environments. The team now consists of a core group of developers with a good understanding of the PHP code base. These developers spend a lot of their time localizing and fixing bugs within PHP. In addition there are many other team members who test and provide feedback on these fixes using a wide variety of platforms.

PHP-GTK

PHP-GTK is the PHP solution for writing client side GUI applications. Andrei Zmievski remembers the planing and creation process of PHP-GTK:

GUI programming has always been of my interests, and I found that Gtk+ is a very nice toolkit, except that programming with it in C is somewhat tedious. After witnessing PyGtk and GTK-Perl implementations, I decided to see if PHP could be made to interface with Gtk+, even minimally. Starting in August of 2000, I began to have a bit more free time so that is when I started experimenting. My main guideline was the PyGtk implementation as it was fairly feature complete and had a nice object-oriented interface. James Henstridge, the author of PyGtk, provided very helpful advice during those initial stages.
Hand-writing the interfaces to all the Gtk+ functions was out of the question, so I seized upon the idea of code-generator, similar to how PyGtk did it. The code generator is a PHP program that reads a set of .defs file containing the Gtk+ classes, constants, and methods information and generates C code that interfaces PHP with them. What cannot be generated automatically can be written by hand in .overrides file.
Working on the code generator and the infrastructure took some time, because I could spend little time on PHP-GTK during the fall of 2000. After I showed PHP-GTK to Frank Kromann, he got interested and started helping me out with code generator work and Win32 implementation. When we wrote the first Hello World program and fired it up, it was extremely exciting. It took a couple more months to get the project to a presentable condition and the initial version was released on March 1, 2001. The story promptly hit SlashDot.
Sensing that PHP-GTK might be extensive, I set up separate mailing lists and CVS repositories for it, as well as the gtk.php.net website with the help of Colin Viebrock. The documentation would also need to be done and James Moore came in to help with that.
Since its release PHP-GTK has been gaining popularity. We have our own documentation team, the manual keeps improving, people start writing extensions for PHP-GTK, and more and more exciting applications with it.

Read more »

Educational Pathways

mail

mail

Description

Parameters

Return Values

ChangeLog

Examples

Notes

ezmlm_hash

ezmlm_hash

Description

Parameters

Return Values

Examples ezmlm_hash

PHP type comparison tables

PHP Navigations

HTTP authentication with PHP

HTTP authentication with PHP

HTTP authentication with PHP

Debugger Protocol PHP

Debugger Protocol PHP

Debugging PHP

About Debugging PHP

Using the Debugger PHP

Using the Debugger PHP

History of PHP related projects

History of PHP related projects

PEAR

PHP Quality Assurance Initiative

PHP-GTK

Categories